diff a/modules/javafx.media/src/main/native/gstreamer/3rd_party/libffi/src/x86/win32.S b/modules/javafx.media/src/main/native/gstreamer/3rd_party/libffi/src/x86/win32.S
--- a/modules/javafx.media/src/main/native/gstreamer/3rd_party/libffi/src/x86/win32.S
+++ /dev/null
@@ -1,1351 +0,0 @@
-/* -----------------------------------------------------------------------
-   win32.S - Copyright (c) 2014  Anthony Green
-             Copyright (c) 1996, 1998, 2001, 2002, 2009  Red Hat, Inc.
-             Copyright (c) 2001  John Beniton
-             Copyright (c) 2002  Ranjit Mathew
-             Copyright (c) 2009  Daniel Witte
-
-
-   X86 Foreign Function Interface
- 
-   Permission is hereby granted, free of charge, to any person obtaining
-   a copy of this software and associated documentation files (the
-   ``Software''), to deal in the Software without restriction, including
-   without limitation the rights to use, copy, modify, merge, publish,
-   distribute, sublicense, and/or sell copies of the Software, and to
-   permit persons to whom the Software is furnished to do so, subject to
-   the following conditions:
- 
-   The above copyright notice and this permission notice shall be included
-   in all copies or substantial portions of the Software.
- 
-   THE SOFTWARE IS PROVIDED ``AS IS'', WITHOUT WARRANTY OF ANY KIND,
-   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-   NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-   DEALINGS IN THE SOFTWARE.
-   -----------------------------------------------------------------------
-   */
- 
-#define LIBFFI_ASM
-#include <fficonfig.h>
-#include <ffi.h>
-
-#define CIF_BYTES_OFFSET 16
-#define CIF_FLAGS_OFFSET 20
-
-#ifdef _MSC_VER
-
-#define CLOSURE_CIF_OFFSET ((FFI_TRAMPOLINE_SIZE + 3) AND NOT 3)
-
-.386
-.MODEL FLAT, C
-
-EXTRN ffi_closure_SYSV_inner:NEAR
-EXTRN ffi_closure_WIN32_inner:NEAR
-
-_TEXT SEGMENT
-
-ffi_call_win32 PROC NEAR,
-    ffi_prep_args : NEAR PTR DWORD,
-    ecif          : NEAR PTR DWORD,
-    cif_abi       : DWORD,
-    cif_bytes     : DWORD,
-    cif_flags     : DWORD,
-    rvalue        : NEAR PTR DWORD,
-    fn            : NEAR PTR DWORD
-
-        ;; Make room for all of the new args.
-        mov  ecx, cif_bytes
-        sub  esp, ecx
-
-        mov  eax, esp
-
-        ;; Call ffi_prep_args
-        push ecif
-        push eax
-        call ffi_prep_args
-        add  esp, 8
-
-        ;; Prepare registers
-        ;; EAX stores the number of register arguments
-        cmp  eax, 0
-        je   fun
-        cmp  eax, 3
-        jl   prepr_two_cmp
-        
-        mov  ecx, esp
-        add  esp, 12
-        mov  eax, DWORD PTR [ecx+8]
-        jmp  prepr_two
-prepr_two_cmp:
-        cmp  eax, 2
-        jl   prepr_one_prep
-        mov  ecx, esp
-        add  esp, 8
-prepr_two:
-        mov  edx, DWORD PTR [ecx+4]
-        jmp  prepr_one
-prepr_one_prep:
-        mov  ecx, esp
-        add  esp, 4
-prepr_one:
-        mov  ecx, DWORD PTR [ecx]
-        cmp  cif_abi, 7 ;; FFI_REGISTER
-        jne  fun
-
-        xchg ecx, eax
-
-fun:
-        ;; Call function
-        call fn
-
-        ;; Load ecx with the return type code
-        mov  ecx, cif_flags
-
-        ;; If the return value pointer is NULL, assume no return value.
-        cmp  rvalue, 0
-        jne  ca_jumptable
-
-        ;; Even if there is no space for the return value, we are
-        ;; obliged to handle floating-point values.
-        cmp  ecx, FFI_TYPE_FLOAT
-        jne  ca_epilogue
-        fstp st(0)
-
-        jmp  ca_epilogue
-
-ca_jumptable:
-        jmp  [ca_jumpdata + 4 * ecx]
-ca_jumpdata:
-        ;; Do not insert anything here between label and jump table.
-        dd offset ca_epilogue       ;; FFI_TYPE_VOID
-        dd offset ca_retint         ;; FFI_TYPE_INT
-        dd offset ca_retfloat       ;; FFI_TYPE_FLOAT
-        dd offset ca_retdouble      ;; FFI_TYPE_DOUBLE
-        dd offset ca_retlongdouble  ;; FFI_TYPE_LONGDOUBLE
-        dd offset ca_retuint8       ;; FFI_TYPE_UINT8
-        dd offset ca_retsint8       ;; FFI_TYPE_SINT8
-        dd offset ca_retuint16      ;; FFI_TYPE_UINT16
-        dd offset ca_retsint16      ;; FFI_TYPE_SINT16
-        dd offset ca_retint         ;; FFI_TYPE_UINT32
-        dd offset ca_retint         ;; FFI_TYPE_SINT32
-        dd offset ca_retint64       ;; FFI_TYPE_UINT64
-        dd offset ca_retint64       ;; FFI_TYPE_SINT64
-        dd offset ca_epilogue       ;; FFI_TYPE_STRUCT
-        dd offset ca_retint         ;; FFI_TYPE_POINTER
-        dd offset ca_retstruct1b    ;; FFI_TYPE_SMALL_STRUCT_1B
-        dd offset ca_retstruct2b    ;; FFI_TYPE_SMALL_STRUCT_2B
-        dd offset ca_retint         ;; FFI_TYPE_SMALL_STRUCT_4B
-        dd offset ca_epilogue       ;; FFI_TYPE_MS_STRUCT
-
-        /* Sign/zero extend as appropriate.  */
-ca_retuint8:
-        movzx eax, al
-        jmp   ca_retint
-
-ca_retsint8:
-        movsx eax, al
-        jmp   ca_retint
-
-ca_retuint16:
-        movzx eax, ax
-        jmp   ca_retint
-
-ca_retsint16:
-        movsx eax, ax
-        jmp   ca_retint
-
-ca_retint:
-        ;; Load %ecx with the pointer to storage for the return value
-        mov   ecx, rvalue
-        mov   [ecx + 0], eax
-        jmp   ca_epilogue
-
-ca_retint64:
-        ;; Load %ecx with the pointer to storage for the return value
-        mov   ecx, rvalue
-        mov   [ecx + 0], eax
-        mov   [ecx + 4], edx
-        jmp   ca_epilogue
-
-ca_retfloat:
-        ;; Load %ecx with the pointer to storage for the return value
-        mov   ecx, rvalue
-        fstp  DWORD PTR [ecx]
-        jmp   ca_epilogue
-
-ca_retdouble:
-        ;; Load %ecx with the pointer to storage for the return value
-        mov   ecx, rvalue
-        fstp  QWORD PTR [ecx]
-        jmp   ca_epilogue
-
-ca_retlongdouble:
-        ;; Load %ecx with the pointer to storage for the return value
-        mov   ecx, rvalue
-        fstp  TBYTE PTR [ecx]
-        jmp   ca_epilogue
-
-ca_retstruct1b:
-        ;; Load %ecx with the pointer to storage for the return value
-        mov   ecx, rvalue
-        mov   [ecx + 0], al
-        jmp   ca_epilogue
-
-ca_retstruct2b:
-        ;; Load %ecx with the pointer to storage for the return value
-        mov   ecx, rvalue
-        mov   [ecx + 0], ax
-        jmp   ca_epilogue
-
-ca_epilogue:
-        ;; Epilogue code is autogenerated.
-        ret
-ffi_call_win32 ENDP
-
-ffi_closure_THISCALL PROC NEAR
-        ;; Insert the register argument on the stack as the first argument
-        xchg	DWORD PTR [esp+4], ecx
-        xchg	DWORD PTR [esp], ecx
-        push	ecx
-        jmp	ffi_closure_STDCALL
-ffi_closure_THISCALL ENDP
-
-ffi_closure_FASTCALL PROC NEAR
-        ;; Insert the 2 register arguments on the stack as the first argument
-        xchg	DWORD PTR [esp+4], edx
-        xchg	DWORD PTR [esp], ecx
-        push	edx
-        push	ecx
-        jmp	ffi_closure_STDCALL
-ffi_closure_FASTCALL ENDP
-
-ffi_closure_REGISTER PROC NEAR
-        ;; Insert the 3 register arguments on the stack as the first argument
-        push	eax
-        xchg	DWORD PTR [esp+8], ecx
-        xchg	DWORD PTR [esp+4], edx
-        push	ecx
-        push	edx
-        jmp	ffi_closure_STDCALL
-ffi_closure_REGISTER ENDP
-
-ffi_closure_SYSV PROC NEAR FORCEFRAME
-    ;; the ffi_closure ctx is passed in eax by the trampoline.
-
-        sub  esp, 40
-        lea  edx, [ebp - 24]
-        mov  [ebp - 12], edx         ;; resp
-        lea  edx, [ebp + 8]
-stub::
-        mov  [esp + 8], edx          ;; args
-        lea  edx, [ebp - 12]
-        mov  [esp + 4], edx          ;; &resp
-        mov  [esp], eax              ;; closure
-        call ffi_closure_SYSV_inner
-        mov  ecx, [ebp - 12]
-
-cs_jumptable:
-        jmp  [cs_jumpdata + 4 * eax]
-cs_jumpdata:
-        ;; Do not insert anything here between the label and jump table.
-        dd offset cs_epilogue       ;; FFI_TYPE_VOID
-        dd offset cs_retint         ;; FFI_TYPE_INT
-        dd offset cs_retfloat       ;; FFI_TYPE_FLOAT
-        dd offset cs_retdouble      ;; FFI_TYPE_DOUBLE
-        dd offset cs_retlongdouble  ;; FFI_TYPE_LONGDOUBLE
-        dd offset cs_retuint8       ;; FFI_TYPE_UINT8
-        dd offset cs_retsint8       ;; FFI_TYPE_SINT8
-        dd offset cs_retuint16      ;; FFI_TYPE_UINT16
-        dd offset cs_retsint16      ;; FFI_TYPE_SINT16
-        dd offset cs_retint         ;; FFI_TYPE_UINT32
-        dd offset cs_retint         ;; FFI_TYPE_SINT32
-        dd offset cs_retint64       ;; FFI_TYPE_UINT64
-        dd offset cs_retint64       ;; FFI_TYPE_SINT64
-        dd offset cs_retstruct      ;; FFI_TYPE_STRUCT
-        dd offset cs_retint         ;; FFI_TYPE_POINTER
-        dd offset cs_retsint8       ;; FFI_TYPE_SMALL_STRUCT_1B
-        dd offset cs_retsint16      ;; FFI_TYPE_SMALL_STRUCT_2B
-        dd offset cs_retint         ;; FFI_TYPE_SMALL_STRUCT_4B
-        dd offset cs_retmsstruct    ;; FFI_TYPE_MS_STRUCT
-
-cs_retuint8:
-        movzx eax, BYTE PTR [ecx]
-        jmp   cs_epilogue
-
-cs_retsint8:
-        movsx eax, BYTE PTR [ecx]
-        jmp   cs_epilogue
-
-cs_retuint16:
-        movzx eax, WORD PTR [ecx]
-        jmp   cs_epilogue
-
-cs_retsint16:
-        movsx eax, WORD PTR [ecx]
-        jmp   cs_epilogue
-
-cs_retint:
-        mov   eax, [ecx]
-        jmp   cs_epilogue
-
-cs_retint64:
-        mov   eax, [ecx + 0]
-        mov   edx, [ecx + 4]
-        jmp   cs_epilogue
-
-cs_retfloat:
-        fld   DWORD PTR [ecx]
-        jmp   cs_epilogue
-
-cs_retdouble:
-        fld   QWORD PTR [ecx]
-        jmp   cs_epilogue
-
-cs_retlongdouble:
-        fld   TBYTE PTR [ecx]
-        jmp   cs_epilogue
-
-cs_retstruct:
-        ;; Caller expects us to pop struct return value pointer hidden arg.
-        ;; Epilogue code is autogenerated.
-        ret	4
-
-cs_retmsstruct:
-        ;; Caller expects us to return a pointer to the real return value.
-        mov   eax, ecx
-        ;; Caller doesn't expects us to pop struct return value pointer hidden arg.
-        jmp   cs_epilogue
-
-cs_epilogue:
-        ;; Epilogue code is autogenerated.
-        ret
-ffi_closure_SYSV ENDP
-
-#if !FFI_NO_RAW_API
-
-#define RAW_CLOSURE_CIF_OFFSET ((FFI_TRAMPOLINE_SIZE + 3) AND NOT 3)
-#define RAW_CLOSURE_FUN_OFFSET (RAW_CLOSURE_CIF_OFFSET + 4)
-#define RAW_CLOSURE_USER_DATA_OFFSET (RAW_CLOSURE_FUN_OFFSET + 4)
-
-ffi_closure_raw_THISCALL PROC NEAR USES esi FORCEFRAME
-        sub esp, 36
-        mov  esi, [eax + RAW_CLOSURE_CIF_OFFSET]        ;; closure->cif
-        mov  edx, [eax + RAW_CLOSURE_USER_DATA_OFFSET]  ;; closure->user_data
-        mov [esp + 12], edx
-        lea edx, [ebp + 12]
-        jmp stubraw
-ffi_closure_raw_THISCALL ENDP
-
-ffi_closure_raw_SYSV PROC NEAR USES esi FORCEFRAME
-    ;; the ffi_closure ctx is passed in eax by the trampoline.
-
-        sub  esp, 40
-        mov  esi, [eax + RAW_CLOSURE_CIF_OFFSET]        ;; closure->cif
-        mov  edx, [eax + RAW_CLOSURE_USER_DATA_OFFSET]  ;; closure->user_data
-        mov  [esp + 12], edx                            ;; user_data
-        lea  edx, [ebp + 8]
-stubraw::
-        mov  [esp + 8], edx                             ;; raw_args
-        lea  edx, [ebp - 24]
-        mov  [esp + 4], edx                             ;; &res
-        mov  [esp], esi                                 ;; cif
-        call DWORD PTR [eax + RAW_CLOSURE_FUN_OFFSET]   ;; closure->fun
-        mov  eax, [esi + CIF_FLAGS_OFFSET]              ;; cif->flags
-        lea  ecx, [ebp - 24]
-
-cr_jumptable:
-        jmp  [cr_jumpdata + 4 * eax]
-cr_jumpdata:
-        ;; Do not insert anything here between the label and jump table.
-        dd offset cr_epilogue       ;; FFI_TYPE_VOID
-        dd offset cr_retint         ;; FFI_TYPE_INT
-        dd offset cr_retfloat       ;; FFI_TYPE_FLOAT
-        dd offset cr_retdouble      ;; FFI_TYPE_DOUBLE
-        dd offset cr_retlongdouble  ;; FFI_TYPE_LONGDOUBLE
-        dd offset cr_retuint8       ;; FFI_TYPE_UINT8
-        dd offset cr_retsint8       ;; FFI_TYPE_SINT8
-        dd offset cr_retuint16      ;; FFI_TYPE_UINT16
-        dd offset cr_retsint16      ;; FFI_TYPE_SINT16
-        dd offset cr_retint         ;; FFI_TYPE_UINT32
-        dd offset cr_retint         ;; FFI_TYPE_SINT32
-        dd offset cr_retint64       ;; FFI_TYPE_UINT64
-        dd offset cr_retint64       ;; FFI_TYPE_SINT64
-        dd offset cr_epilogue       ;; FFI_TYPE_STRUCT
-        dd offset cr_retint         ;; FFI_TYPE_POINTER
-        dd offset cr_retsint8       ;; FFI_TYPE_SMALL_STRUCT_1B
-        dd offset cr_retsint16      ;; FFI_TYPE_SMALL_STRUCT_2B
-        dd offset cr_retint         ;; FFI_TYPE_SMALL_STRUCT_4B
-        dd offset cr_epilogue       ;; FFI_TYPE_MS_STRUCT
-
-cr_retuint8:
-        movzx eax, BYTE PTR [ecx]
-        jmp   cr_epilogue
-
-cr_retsint8:
-        movsx eax, BYTE PTR [ecx]
-        jmp   cr_epilogue
-
-cr_retuint16:
-        movzx eax, WORD PTR [ecx]
-        jmp   cr_epilogue
-
-cr_retsint16:
-        movsx eax, WORD PTR [ecx]
-        jmp   cr_epilogue
-
-cr_retint:
-        mov   eax, [ecx]
-        jmp   cr_epilogue
-
-cr_retint64:
-        mov   eax, [ecx + 0]
-        mov   edx, [ecx + 4]
-        jmp   cr_epilogue
-
-cr_retfloat:
-        fld   DWORD PTR [ecx]
-        jmp   cr_epilogue
-
-cr_retdouble:
-        fld   QWORD PTR [ecx]
-        jmp   cr_epilogue
-
-cr_retlongdouble:
-        fld   TBYTE PTR [ecx]
-        jmp   cr_epilogue
-
-cr_epilogue:
-        ;; Epilogue code is autogenerated.
-        ret
-ffi_closure_raw_SYSV ENDP
-
-#endif /* !FFI_NO_RAW_API */
-
-ffi_closure_STDCALL PROC NEAR FORCEFRAME
-        mov  eax, [esp] ;; the ffi_closure ctx passed by the trampoline.
-
-        sub  esp, 40
-        lea  edx, [ebp - 24]
-        mov  [ebp - 12], edx         ;; resp
-        lea  edx, [ebp + 12]         ;; account for stub return address on stack
-        mov  [esp + 8], edx          ;; args
-        lea  edx, [ebp - 12]
-        mov  [esp + 4], edx          ;; &resp
-        mov  [esp], eax              ;; closure
-        call ffi_closure_WIN32_inner
-        mov  ecx, [ebp - 12]
-
-        xchg [ebp + 4], eax          ;;xchg size of stack parameters and ffi_closure ctx
-        mov  eax, DWORD PTR [eax + CLOSURE_CIF_OFFSET]
-        mov  eax, DWORD PTR [eax + CIF_FLAGS_OFFSET]
-
-cd_jumptable:
-        jmp  [cd_jumpdata + 4 * eax]
-cd_jumpdata:
-        ;; Do not insert anything here between the label and jump table.
-        dd offset cd_epilogue       ;; FFI_TYPE_VOID
-        dd offset cd_retint         ;; FFI_TYPE_INT
-        dd offset cd_retfloat       ;; FFI_TYPE_FLOAT
-        dd offset cd_retdouble      ;; FFI_TYPE_DOUBLE
-        dd offset cd_retlongdouble  ;; FFI_TYPE_LONGDOUBLE
-        dd offset cd_retuint8       ;; FFI_TYPE_UINT8
-        dd offset cd_retsint8       ;; FFI_TYPE_SINT8
-        dd offset cd_retuint16      ;; FFI_TYPE_UINT16
-        dd offset cd_retsint16      ;; FFI_TYPE_SINT16
-        dd offset cd_retint         ;; FFI_TYPE_UINT32
-        dd offset cd_retint         ;; FFI_TYPE_SINT32
-        dd offset cd_retint64       ;; FFI_TYPE_UINT64
-        dd offset cd_retint64       ;; FFI_TYPE_SINT64
-        dd offset cd_epilogue       ;; FFI_TYPE_STRUCT
-        dd offset cd_retint         ;; FFI_TYPE_POINTER
-        dd offset cd_retsint8       ;; FFI_TYPE_SMALL_STRUCT_1B
-        dd offset cd_retsint16      ;; FFI_TYPE_SMALL_STRUCT_2B
-        dd offset cd_retint         ;; FFI_TYPE_SMALL_STRUCT_4B
-
-cd_retuint8:
-        movzx eax, BYTE PTR [ecx]
-        jmp   cd_epilogue
-
-cd_retsint8:
-        movsx eax, BYTE PTR [ecx]
-        jmp   cd_epilogue
-
-cd_retuint16:
-        movzx eax, WORD PTR [ecx]
-        jmp   cd_epilogue
-
-cd_retsint16:
-        movsx eax, WORD PTR [ecx]
-        jmp   cd_epilogue
-
-cd_retint:
-        mov   eax, [ecx]
-        jmp   cd_epilogue
-
-cd_retint64:
-        mov   eax, [ecx + 0]
-        mov   edx, [ecx + 4]
-        jmp   cd_epilogue
-
-cd_retfloat:
-        fld   DWORD PTR [ecx]
-        jmp   cd_epilogue
-
-cd_retdouble:
-        fld   QWORD PTR [ecx]
-        jmp   cd_epilogue
-
-cd_retlongdouble:
-        fld   TBYTE PTR [ecx]
-        jmp   cd_epilogue
-
-cd_epilogue:
-        mov   esp, ebp
-        pop   ebp
-        mov   ecx, [esp + 4]  ;; Return address
-        add   esp, [esp]      ;; Parameters stack size
-        add   esp, 8
-        jmp   ecx
-ffi_closure_STDCALL ENDP
-
-_TEXT ENDS
-END
-
-#else
-
-#define CLOSURE_CIF_OFFSET ((FFI_TRAMPOLINE_SIZE + 3) & ~3)
-
-#if defined(SYMBOL_UNDERSCORE)
-#define USCORE_SYMBOL(x) _##x
-#else
-#define USCORE_SYMBOL(x) x
-#endif
-        .text
- 
-        # This assumes we are using gas.
-        .balign 16
-FFI_HIDDEN(ffi_call_win32)
-        .globl	USCORE_SYMBOL(ffi_call_win32)
-#if defined(X86_WIN32) && !defined(__OS2__)
-        .def	_ffi_call_win32;	.scl	2;	.type	32;	.endef
-#endif
-USCORE_SYMBOL(ffi_call_win32):
-.LFB1:
-        pushl %ebp
-.LCFI0:
-        movl  %esp,%ebp
-.LCFI1:
-        # Make room for all of the new args.
-        movl  20(%ebp),%ecx                                                     
-        subl  %ecx,%esp
- 
-        movl  %esp,%eax
- 
-        # Call ffi_prep_args
-        pushl 12(%ebp)
-        pushl %eax
-        call  *8(%ebp)
-        addl  $8,%esp
-
-        # Prepare registers
-        # EAX stores the number of register arguments
-        cmpl  $0, %eax
-        je    .fun
-        cmpl  $3, %eax
-        jl    .prepr_two_cmp
-        
-        movl  %esp, %ecx
-        addl  $12, %esp
-        movl  8(%ecx), %eax
-        jmp   .prepr_two
-.prepr_two_cmp:
-        cmpl  $2, %eax
-        jl    .prepr_one_prep
-        movl  %esp, %ecx
-        addl  $8, %esp
-.prepr_two:
-        movl  4(%ecx), %edx
-        jmp   .prepr_one
-.prepr_one_prep:
-        movl  %esp, %ecx
-        addl  $4, %esp
-.prepr_one:
-        movl  (%ecx), %ecx
-        cmpl  $7, 16(%ebp) # FFI_REGISTER
-        jne   .fun
-
-        xchgl %eax, %ecx
-        
-.fun:
-        # FIXME: Align the stack to a 128-bit boundary to avoid
-        # potential performance hits.
-
-        # Call function
-        call  *32(%ebp)
- 
-        # stdcall functions pop arguments off the stack themselves
-
-        # Load %ecx with the return type code
-        movl  24(%ebp),%ecx
- 
-        # If the return value pointer is NULL, assume no return value.
-        cmpl  $0,28(%ebp)
-        jne   0f
- 
-        # Even if there is no space for the return value, we are
-        # obliged to handle floating-point values.
-        cmpl  $FFI_TYPE_FLOAT,%ecx
-        jne   .Lnoretval
-        fstp  %st(0)
- 
-        jmp   .Lepilogue
-
-0:
-        call 1f
-        # Do not insert anything here between the call and the jump table.
-.Lstore_table:
-        .long	.Lnoretval-.Lstore_table	/* FFI_TYPE_VOID */
-        .long	.Lretint-.Lstore_table		/* FFI_TYPE_INT */
-        .long	.Lretfloat-.Lstore_table	/* FFI_TYPE_FLOAT */
-        .long	.Lretdouble-.Lstore_table	/* FFI_TYPE_DOUBLE */
-        .long	.Lretlongdouble-.Lstore_table	/* FFI_TYPE_LONGDOUBLE */
-        .long	.Lretuint8-.Lstore_table	/* FFI_TYPE_UINT8 */
-        .long	.Lretsint8-.Lstore_table	/* FFI_TYPE_SINT8 */
-        .long	.Lretuint16-.Lstore_table	/* FFI_TYPE_UINT16 */
-        .long	.Lretsint16-.Lstore_table	/* FFI_TYPE_SINT16 */
-        .long	.Lretint-.Lstore_table		/* FFI_TYPE_UINT32 */
-        .long	.Lretint-.Lstore_table		/* FFI_TYPE_SINT32 */
-        .long	.Lretint64-.Lstore_table	/* FFI_TYPE_UINT64 */
-        .long	.Lretint64-.Lstore_table	/* FFI_TYPE_SINT64 */
-        .long	.Lretstruct-.Lstore_table	/* FFI_TYPE_STRUCT */
-        .long	.Lretint-.Lstore_table		/* FFI_TYPE_POINTER */
-        .long	.Lretstruct1b-.Lstore_table	/* FFI_TYPE_SMALL_STRUCT_1B */
-        .long	.Lretstruct2b-.Lstore_table	/* FFI_TYPE_SMALL_STRUCT_2B */
-        .long	.Lretstruct4b-.Lstore_table	/* FFI_TYPE_SMALL_STRUCT_4B */
-        .long	.Lretstruct-.Lstore_table	/* FFI_TYPE_MS_STRUCT */
-1:
-        shl	$2, %ecx
-        add	(%esp),%ecx
-        mov	(%ecx),%ecx
-        add	(%esp),%ecx
-        add	$4, %esp
-        jmp	*%ecx
-
-        /* Sign/zero extend as appropriate.  */
-.Lretsint8:
-        movsbl	%al, %eax
-        jmp	.Lretint
-
-.Lretsint16:
-        movswl	%ax, %eax
-        jmp	.Lretint
-
-.Lretuint8:
-        movzbl	%al, %eax
-        jmp	.Lretint
-
-.Lretuint16:
-        movzwl	%ax, %eax
-        jmp	.Lretint
-
-.Lretint:
-        # Load %ecx with the pointer to storage for the return value
-        movl  28(%ebp),%ecx
-        movl  %eax,0(%ecx)
-        jmp   .Lepilogue
- 
-.Lretfloat:
-         # Load %ecx with the pointer to storage for the return value
-        movl  28(%ebp),%ecx
-        fstps (%ecx)
-        jmp   .Lepilogue
- 
-.Lretdouble:
-        # Load %ecx with the pointer to storage for the return value
-        movl  28(%ebp),%ecx
-        fstpl (%ecx)
-        jmp   .Lepilogue
- 
-.Lretlongdouble:
-        # Load %ecx with the pointer to storage for the return value
-        movl  28(%ebp),%ecx
-        fstpt (%ecx)
-        jmp   .Lepilogue
- 
-.Lretint64:
-        # Load %ecx with the pointer to storage for the return value
-        movl  28(%ebp),%ecx
-        movl  %eax,0(%ecx)
-        movl  %edx,4(%ecx)
-        jmp   .Lepilogue
-
-.Lretstruct1b:
-        # Load %ecx with the pointer to storage for the return value
-        movl  28(%ebp),%ecx
-        movb  %al,0(%ecx)
-        jmp   .Lepilogue
- 
-.Lretstruct2b:
-        # Load %ecx with the pointer to storage for the return value
-        movl  28(%ebp),%ecx
-        movw  %ax,0(%ecx)
-        jmp   .Lepilogue
-
-.Lretstruct4b:
-        # Load %ecx with the pointer to storage for the return value
-        movl  28(%ebp),%ecx
-        movl  %eax,0(%ecx)
-        jmp   .Lepilogue
-
-.Lretstruct:
-        # Nothing to do!
- 
-.Lnoretval:
-.Lepilogue:
-        movl %ebp,%esp
-        popl %ebp
-        ret
-.ffi_call_win32_end:
-        .balign 16
-FFI_HIDDEN(ffi_closure_THISCALL)
-        .globl	USCORE_SYMBOL(ffi_closure_THISCALL)
-#if defined(X86_WIN32) && !defined(__OS2__)
-        .def	_ffi_closure_THISCALL;	.scl	2;	.type	32;	.endef
-#endif
-USCORE_SYMBOL(ffi_closure_THISCALL):
-        /* Insert the register argument on the stack as the first argument */
-        xchg	%ecx, 4(%esp)
-        xchg	%ecx, (%esp)
-        push	%ecx
-        jmp	.ffi_closure_STDCALL_internal
-
-        .balign 16
-FFI_HIDDEN(ffi_closure_FASTCALL)
-        .globl	USCORE_SYMBOL(ffi_closure_FASTCALL)
-#if defined(X86_WIN32) && !defined(__OS2__)
-        .def	_ffi_closure_FASTCALL;	.scl	2;	.type	32;	.endef
-#endif
-USCORE_SYMBOL(ffi_closure_FASTCALL):
-        /* Insert the 2 register arguments on the stack as the first two arguments */
-        xchg	%edx, 4(%esp)
-        xchg	%ecx, (%esp)
-        push	%edx
-        push	%ecx
-        jmp	.ffi_closure_STDCALL_internal
-FFI_HIDDEN(ffi_closure_REGISTER)
-        .globl	USCORE_SYMBOL(ffi_closure_REGISTER)
-#if defined(X86_WIN32) && !defined(__OS2__)
-        .def	_ffi_closure_REGISTER;	.scl	2;	.type	32;	.endef
-#endif
-USCORE_SYMBOL(ffi_closure_REGISTER):
-        /* Insert the 3 register arguments on the stack as the first two arguments */
-        push	%eax
-        xchg	%ecx, 8(%esp)
-        xchg	%edx, 4(%esp)
-        push	%ecx
-        push	%edx
-        jmp	.ffi_closure_STDCALL_internal
-
-.LFE1:
-        # This assumes we are using gas.
-        .balign 16
-FFI_HIDDEN(ffi_closure_SYSV)
-#if defined(X86_WIN32)
-        .globl	USCORE_SYMBOL(ffi_closure_SYSV)
-#if defined(X86_WIN32) && !defined(__OS2__)
-        .def	_ffi_closure_SYSV;	.scl	2;	.type	32;	.endef
-#endif
-USCORE_SYMBOL(ffi_closure_SYSV):
-#endif
-.LFB3:
-        pushl	%ebp
-.LCFI4:
-        movl	%esp, %ebp
-.LCFI5:
-        subl	$40, %esp
-        leal	-24(%ebp), %edx
-        movl	%edx, -12(%ebp)	/* resp */
-        leal	8(%ebp), %edx
-        movl	%edx, 4(%esp)	/* args = __builtin_dwarf_cfa () */
-        leal	-12(%ebp), %edx
-        movl	%edx, (%esp)	/* &resp */
-#if defined(HAVE_HIDDEN_VISIBILITY_ATTRIBUTE) || !defined(__PIC__)
-        call	USCORE_SYMBOL(ffi_closure_SYSV_inner)
-#elif defined(X86_DARWIN)
-        calll	L_ffi_closure_SYSV_inner$stub
-#else
-        movl	%ebx, 8(%esp)
-        call	1f
-1:      popl	%ebx
-        addl	$_GLOBAL_OFFSET_TABLE_+[.-1b], %ebx
-        call	ffi_closure_SYSV_inner@PLT
-        movl	8(%esp), %ebx
-#endif
-        movl	-12(%ebp), %ecx
-
-0:
-        call	1f
-        # Do not insert anything here between the call and the jump table.
-.Lcls_store_table:
-        .long	.Lcls_noretval-.Lcls_store_table	/* FFI_TYPE_VOID */
-        .long	.Lcls_retint-.Lcls_store_table		/* FFI_TYPE_INT */
-        .long	.Lcls_retfloat-.Lcls_store_table	/* FFI_TYPE_FLOAT */
-        .long	.Lcls_retdouble-.Lcls_store_table	/* FFI_TYPE_DOUBLE */
-        .long	.Lcls_retldouble-.Lcls_store_table	/* FFI_TYPE_LONGDOUBLE */
-        .long	.Lcls_retuint8-.Lcls_store_table	/* FFI_TYPE_UINT8 */
-        .long	.Lcls_retsint8-.Lcls_store_table	/* FFI_TYPE_SINT8 */
-        .long	.Lcls_retuint16-.Lcls_store_table	/* FFI_TYPE_UINT16 */
-        .long	.Lcls_retsint16-.Lcls_store_table	/* FFI_TYPE_SINT16 */
-        .long	.Lcls_retint-.Lcls_store_table		/* FFI_TYPE_UINT32 */
-        .long	.Lcls_retint-.Lcls_store_table		/* FFI_TYPE_SINT32 */
-        .long	.Lcls_retllong-.Lcls_store_table	/* FFI_TYPE_UINT64 */
-        .long	.Lcls_retllong-.Lcls_store_table	/* FFI_TYPE_SINT64 */
-        .long	.Lcls_retstruct-.Lcls_store_table	/* FFI_TYPE_STRUCT */
-        .long	.Lcls_retint-.Lcls_store_table		/* FFI_TYPE_POINTER */
-        .long	.Lcls_retstruct1-.Lcls_store_table	/* FFI_TYPE_SMALL_STRUCT_1B */
-        .long	.Lcls_retstruct2-.Lcls_store_table	/* FFI_TYPE_SMALL_STRUCT_2B */
-        .long	.Lcls_retstruct4-.Lcls_store_table	/* FFI_TYPE_SMALL_STRUCT_4B */
-        .long	.Lcls_retmsstruct-.Lcls_store_table	/* FFI_TYPE_MS_STRUCT */
-
-1:
-        shl	$2, %eax
-        add	(%esp),%eax
-        mov	(%eax),%eax
-        add	(%esp),%eax
-        add	$4, %esp
-        jmp	*%eax
-
-        /* Sign/zero extend as appropriate.  */
-.Lcls_retsint8:
-        movsbl	(%ecx), %eax
-        jmp	.Lcls_epilogue
-
-.Lcls_retsint16:
-        movswl	(%ecx), %eax
-        jmp	.Lcls_epilogue
-
-.Lcls_retuint8:
-        movzbl	(%ecx), %eax
-        jmp	.Lcls_epilogue
-
-.Lcls_retuint16:
-        movzwl	(%ecx), %eax
-        jmp	.Lcls_epilogue
-
-.Lcls_retint:
-        movl	(%ecx), %eax
-        jmp	.Lcls_epilogue
-
-.Lcls_retfloat:
-        flds	(%ecx)
-        jmp	.Lcls_epilogue
-
-.Lcls_retdouble:
-        fldl	(%ecx)
-        jmp	.Lcls_epilogue
-
-.Lcls_retldouble:
-        fldt	(%ecx)
-        jmp	.Lcls_epilogue
-
-.Lcls_retllong:
-        movl	(%ecx), %eax
-        movl	4(%ecx), %edx
-        jmp	.Lcls_epilogue
-
-.Lcls_retstruct1:
-        movsbl	(%ecx), %eax
-        jmp	.Lcls_epilogue
-
-.Lcls_retstruct2:
-        movswl	(%ecx), %eax
-        jmp	.Lcls_epilogue
-
-.Lcls_retstruct4:
-        movl	(%ecx), %eax
-        jmp	.Lcls_epilogue
-
-.Lcls_retstruct:
-        # Caller expects us to pop struct return value pointer hidden arg.
-        movl	%ebp, %esp
-        popl	%ebp
-        ret	$0x4
-
-.Lcls_retmsstruct:
-        # Caller expects us to return a pointer to the real return value.
-        mov	%ecx, %eax
-        # Caller doesn't expects us to pop struct return value pointer hidden arg.
-        jmp	.Lcls_epilogue
-
-.Lcls_noretval:
-.Lcls_epilogue:
-        movl	%ebp, %esp
-        popl	%ebp
-        ret
-.ffi_closure_SYSV_end:
-.LFE3:
-
-#if !FFI_NO_RAW_API
-
-#define RAW_CLOSURE_CIF_OFFSET ((FFI_TRAMPOLINE_SIZE + 3) & ~3)
-#define RAW_CLOSURE_FUN_OFFSET (RAW_CLOSURE_CIF_OFFSET + 4)
-#define RAW_CLOSURE_USER_DATA_OFFSET (RAW_CLOSURE_FUN_OFFSET + 4)
-
-#ifdef X86_WIN32
-        .balign 16
-FFI_HIDDEN(ffi_closure_raw_THISCALL)
-        .globl	USCORE_SYMBOL(ffi_closure_raw_THISCALL)
-#if defined(X86_WIN32) && !defined(__OS2__)
-        .def	_ffi_closure_raw_THISCALL;	.scl	2;	.type	32;	.endef
-#endif
-USCORE_SYMBOL(ffi_closure_raw_THISCALL):
-        pushl	%ebp
-        movl	%esp, %ebp
-        pushl	%esi
-        subl	$36, %esp
-        movl	RAW_CLOSURE_CIF_OFFSET(%eax), %esi	 /* closure->cif */
-        movl	RAW_CLOSURE_USER_DATA_OFFSET(%eax), %edx /* closure->user_data */
-        movl	%edx, 12(%esp)	/* user_data */
-        leal	12(%ebp), %edx	/* __builtin_dwarf_cfa () */
-        jmp	.stubraw
-#endif /* X86_WIN32 */
-
-        # This assumes we are using gas.
-        .balign 16
-#if defined(X86_WIN32)
-        .globl	USCORE_SYMBOL(ffi_closure_raw_SYSV)
-#if defined(X86_WIN32) && !defined(__OS2__)
-        .def	_ffi_closure_raw_SYSV;	.scl	2;	.type	32;	.endef
-#endif
-USCORE_SYMBOL(ffi_closure_raw_SYSV):
-#endif /* defined(X86_WIN32) */
-.LFB4:
-        pushl	%ebp
-.LCFI6:
-        movl	%esp, %ebp
-.LCFI7:
-        pushl	%esi
-.LCFI8:
-        subl	$36, %esp
-        movl	RAW_CLOSURE_CIF_OFFSET(%eax), %esi	 /* closure->cif */
-        movl	RAW_CLOSURE_USER_DATA_OFFSET(%eax), %edx /* closure->user_data */
-        movl	%edx, 12(%esp)	/* user_data */
-        leal	8(%ebp), %edx	/* __builtin_dwarf_cfa () */
-.stubraw:
-        movl	%edx, 8(%esp)	/* raw_args */
-        leal	-24(%ebp), %edx
-        movl	%edx, 4(%esp)	/* &res */
-        movl	%esi, (%esp)	/* cif */
-        call	*RAW_CLOSURE_FUN_OFFSET(%eax)		 /* closure->fun */
-        movl	CIF_FLAGS_OFFSET(%esi), %eax		 /* rtype */
-0:
-        call	1f
-        # Do not insert anything here between the call and the jump table.
-.Lrcls_store_table:
-        .long	.Lrcls_noretval-.Lrcls_store_table	/* FFI_TYPE_VOID */
-        .long	.Lrcls_retint-.Lrcls_store_table	/* FFI_TYPE_INT */
-        .long	.Lrcls_retfloat-.Lrcls_store_table	/* FFI_TYPE_FLOAT */
-        .long	.Lrcls_retdouble-.Lrcls_store_table	/* FFI_TYPE_DOUBLE */
-        .long	.Lrcls_retldouble-.Lrcls_store_table	/* FFI_TYPE_LONGDOUBLE */
-        .long	.Lrcls_retuint8-.Lrcls_store_table	/* FFI_TYPE_UINT8 */
-        .long	.Lrcls_retsint8-.Lrcls_store_table	/* FFI_TYPE_SINT8 */
-        .long	.Lrcls_retuint16-.Lrcls_store_table	/* FFI_TYPE_UINT16 */
-        .long	.Lrcls_retsint16-.Lrcls_store_table	/* FFI_TYPE_SINT16 */
-        .long	.Lrcls_retint-.Lrcls_store_table	/* FFI_TYPE_UINT32 */
-        .long	.Lrcls_retint-.Lrcls_store_table	/* FFI_TYPE_SINT32 */
-        .long	.Lrcls_retllong-.Lrcls_store_table	/* FFI_TYPE_UINT64 */
-        .long	.Lrcls_retllong-.Lrcls_store_table	/* FFI_TYPE_SINT64 */
-        .long	.Lrcls_retstruct-.Lrcls_store_table	/* FFI_TYPE_STRUCT */
-        .long	.Lrcls_retint-.Lrcls_store_table	/* FFI_TYPE_POINTER */
-        .long	.Lrcls_retstruct1-.Lrcls_store_table	/* FFI_TYPE_SMALL_STRUCT_1B */
-        .long	.Lrcls_retstruct2-.Lrcls_store_table	/* FFI_TYPE_SMALL_STRUCT_2B */
-        .long	.Lrcls_retstruct4-.Lrcls_store_table	/* FFI_TYPE_SMALL_STRUCT_4B */
-        .long	.Lrcls_retstruct-.Lrcls_store_table	/* FFI_TYPE_MS_STRUCT */
-1:
-        shl	$2, %eax
-        add	(%esp),%eax
-        mov	(%eax),%eax
-        add	(%esp),%eax
-        add	$4, %esp
-        jmp	*%eax
-
-        /* Sign/zero extend as appropriate.  */
-.Lrcls_retsint8:
-        movsbl	-24(%ebp), %eax
-        jmp	.Lrcls_epilogue
-
-.Lrcls_retsint16:
-        movswl	-24(%ebp), %eax
-        jmp	.Lrcls_epilogue
-
-.Lrcls_retuint8:
-        movzbl	-24(%ebp), %eax
-        jmp	.Lrcls_epilogue
-
-.Lrcls_retuint16:
-        movzwl	-24(%ebp), %eax
-        jmp	.Lrcls_epilogue
-
-.Lrcls_retint:
-        movl	-24(%ebp), %eax
-        jmp	.Lrcls_epilogue
-
-.Lrcls_retfloat:
-        flds	-24(%ebp)
-        jmp	.Lrcls_epilogue
-
-.Lrcls_retdouble:
-        fldl	-24(%ebp)
-        jmp	.Lrcls_epilogue
-
-.Lrcls_retldouble:
-        fldt	-24(%ebp)
-        jmp	.Lrcls_epilogue
-
-.Lrcls_retllong:
-        movl	-24(%ebp), %eax
-        movl	-20(%ebp), %edx
-        jmp	.Lrcls_epilogue
-
-.Lrcls_retstruct1:
-        movsbl	-24(%ebp), %eax
-        jmp	.Lrcls_epilogue
-
-.Lrcls_retstruct2:
-        movswl	-24(%ebp), %eax
-        jmp	.Lrcls_epilogue
-
-.Lrcls_retstruct4:
-        movl	-24(%ebp), %eax
-        jmp	.Lrcls_epilogue
-
-.Lrcls_retstruct:
-        # Nothing to do!
-
-.Lrcls_noretval:
-.Lrcls_epilogue:
-        addl	$36, %esp
-        popl	%esi
-        popl	%ebp
-        ret
-.ffi_closure_raw_SYSV_end:
-.LFE4:
-
-#endif /* !FFI_NO_RAW_API */
-
-        # This assumes we are using gas.
-        .balign	16
-FFI_HIDDEN(ffi_closure_STDCALL)
-        .globl	USCORE_SYMBOL(ffi_closure_STDCALL)
-#if defined(X86_WIN32) && !defined(__OS2__)
-        .def	_ffi_closure_STDCALL;	.scl	2;	.type	32;	.endef
-#endif
-USCORE_SYMBOL(ffi_closure_STDCALL):
-.ffi_closure_STDCALL_internal:
-        /* ffi_closure ctx is at top of the stack */
-        movl	(%esp), %eax
-.LFB5:
-        pushl	%ebp
-.LCFI9:
-        movl	%esp, %ebp
-.LCFI10:
-        subl	$40, %esp
-        leal	-24(%ebp), %edx
-        movl	%edx, -12(%ebp)	/* resp */
-        leal	12(%ebp), %edx  /* account for stub return address on stack */
-        movl	%edx, 4(%esp)	/* args */
-        leal	-12(%ebp), %edx
-        movl	%edx, (%esp)	/* &resp */
-#if defined(HAVE_HIDDEN_VISIBILITY_ATTRIBUTE) || !defined(__PIC__)
-        call	USCORE_SYMBOL(ffi_closure_WIN32_inner)
-#elif defined(X86_DARWIN)
-        calll	L_ffi_closure_WIN32_inner$stub
-#else
-        movl	%ebx, 8(%esp)
-        call	1f
-1:      popl	%ebx
-        addl	$_GLOBAL_OFFSET_TABLE_+[.-1b], %ebx
-        call	ffi_closure_WIN32_inner@PLT
-        movl	8(%esp), %ebx
-#endif
-        movl	-12(%ebp), %ecx
-0:
-        xchgl	4(%ebp), %eax /* xchg size of stack parameters and ffi_closure ctx */
-        movl	CLOSURE_CIF_OFFSET(%eax), %eax
-        movl	CIF_FLAGS_OFFSET(%eax), %eax
-
-        call	1f
-        # Do not insert anything here between the call and the jump table.
-.Lscls_store_table:
-        .long	.Lscls_noretval-.Lscls_store_table	/* FFI_TYPE_VOID */
-        .long	.Lscls_retint-.Lscls_store_table	/* FFI_TYPE_INT */
-        .long	.Lscls_retfloat-.Lscls_store_table	/* FFI_TYPE_FLOAT */
-        .long	.Lscls_retdouble-.Lscls_store_table	/* FFI_TYPE_DOUBLE */
-        .long	.Lscls_retldouble-.Lscls_store_table	/* FFI_TYPE_LONGDOUBLE */
-        .long	.Lscls_retuint8-.Lscls_store_table	/* FFI_TYPE_UINT8 */
-        .long	.Lscls_retsint8-.Lscls_store_table	/* FFI_TYPE_SINT8 */
-        .long	.Lscls_retuint16-.Lscls_store_table	/* FFI_TYPE_UINT16 */
-        .long	.Lscls_retsint16-.Lscls_store_table	/* FFI_TYPE_SINT16 */
-        .long	.Lscls_retint-.Lscls_store_table	/* FFI_TYPE_UINT32 */
-        .long	.Lscls_retint-.Lscls_store_table	/* FFI_TYPE_SINT32 */
-        .long	.Lscls_retllong-.Lscls_store_table	/* FFI_TYPE_UINT64 */
-        .long	.Lscls_retllong-.Lscls_store_table	/* FFI_TYPE_SINT64 */
-        .long	.Lscls_retstruct-.Lscls_store_table	/* FFI_TYPE_STRUCT */
-        .long	.Lscls_retint-.Lscls_store_table	/* FFI_TYPE_POINTER */
-        .long	.Lscls_retstruct1-.Lscls_store_table	/* FFI_TYPE_SMALL_STRUCT_1B */
-        .long	.Lscls_retstruct2-.Lscls_store_table	/* FFI_TYPE_SMALL_STRUCT_2B */
-        .long	.Lscls_retstruct4-.Lscls_store_table	/* FFI_TYPE_SMALL_STRUCT_4B */
-1:
-        shl	$2, %eax
-        add	(%esp),%eax
-        mov	(%eax),%eax
-        add	(%esp),%eax
-        add	$4, %esp
-        jmp	*%eax
-
-        /* Sign/zero extend as appropriate.  */
-.Lscls_retsint8:
-        movsbl	(%ecx), %eax
-        jmp	.Lscls_epilogue
-
-.Lscls_retsint16:
-        movswl	(%ecx), %eax
-        jmp	.Lscls_epilogue
-
-.Lscls_retuint8:
-        movzbl	(%ecx), %eax
-        jmp	.Lscls_epilogue
-
-.Lscls_retuint16:
-        movzwl	(%ecx), %eax
-        jmp	.Lscls_epilogue
-
-.Lscls_retint:
-        movl	(%ecx), %eax
-        jmp	.Lscls_epilogue
-
-.Lscls_retfloat:
-        flds	(%ecx)
-        jmp	.Lscls_epilogue
-
-.Lscls_retdouble:
-        fldl	(%ecx)
-        jmp	.Lscls_epilogue
-
-.Lscls_retldouble:
-        fldt	(%ecx)
-        jmp	.Lscls_epilogue
-
-.Lscls_retllong:
-        movl	(%ecx), %eax
-        movl	4(%ecx), %edx
-        jmp	.Lscls_epilogue
-
-.Lscls_retstruct1:
-        movsbl	(%ecx), %eax
-        jmp	.Lscls_epilogue
-
-.Lscls_retstruct2:
-        movswl	(%ecx), %eax
-        jmp	.Lscls_epilogue
-
-.Lscls_retstruct4:
-        movl	(%ecx), %eax
-        jmp	.Lscls_epilogue
-
-.Lscls_retstruct:
-        # Nothing to do!
-
-.Lscls_noretval:
-.Lscls_epilogue:
-        movl	%ebp, %esp
-        popl	%ebp
-        movl	4(%esp), %ecx /* Return address */
-        addl	(%esp), %esp  /* Parameters stack size */
-        addl	$8, %esp
-        jmp	*%ecx
-.ffi_closure_STDCALL_end:
-.LFE5:
-
-#if defined(X86_DARWIN)
-.section __IMPORT,__jump_table,symbol_stubs,self_modifying_code+pure_instructions,5
-L_ffi_closure_SYSV_inner$stub:
-        .indirect_symbol _ffi_closure_SYSV_inner
-        hlt ; hlt ; hlt ; hlt ; hlt
-L_ffi_closure_WIN32_inner$stub:
-        .indirect_symbol _ffi_closure_WIN32_inner
-        hlt ; hlt ; hlt ; hlt ; hlt
-#endif
-
-#if defined(X86_WIN32) && !defined(__OS2__)
-        .section	.eh_frame,"w"
-#endif
-.Lframe1:
-.LSCIE1:
-        .long	.LECIE1-.LASCIE1  /* Length of Common Information Entry */
-.LASCIE1:
-        .long	0x0	/* CIE Identifier Tag */
-        .byte	0x1	/* CIE Version */
-#ifdef __PIC__
-        .ascii "zR\0"	/* CIE Augmentation */
-#else
-        .ascii "\0"	/* CIE Augmentation */
-#endif
-        .byte	0x1	/* .uleb128 0x1; CIE Code Alignment Factor */
-        .byte	0x7c	/* .sleb128 -4; CIE Data Alignment Factor */
-        .byte	0x8	/* CIE RA Column */
-#ifdef __PIC__
-        .byte	0x1	/* .uleb128 0x1; Augmentation size */
-        .byte	0x1b	/* FDE Encoding (pcrel sdata4) */
-#endif
-        .byte	0xc	/* DW_CFA_def_cfa CFA = r4 + 4 = 4(%esp) */
-        .byte	0x4	/* .uleb128 0x4 */
-        .byte	0x4	/* .uleb128 0x4 */
-        .byte	0x88	/* DW_CFA_offset, column 0x8 %eip at CFA + 1 * -4 */
-        .byte	0x1	/* .uleb128 0x1 */
-        .align 4
-.LECIE1:
-
-.LSFDE1:
-        .long	.LEFDE1-.LASFDE1	/* FDE Length */
-.LASFDE1:
-        .long	.LASFDE1-.Lframe1	/* FDE CIE offset */
-#if defined __PIC__ && defined HAVE_AS_X86_PCREL
-        .long	.LFB1-.	/* FDE initial location */
-#else
-        .long	.LFB1
-#endif
-        .long	.LFE1-.LFB1	/* FDE address range */
-#ifdef __PIC__
-        .byte	0x0	/* .uleb128 0x0; Augmentation size */
-#endif
-        /* DW_CFA_xxx CFI instructions go here.  */
-
-        .byte	0x4	/* DW_CFA_advance_loc4 */
-        .long	.LCFI0-.LFB1
-        .byte	0xe	/* DW_CFA_def_cfa_offset CFA = r4 + 8 = 8(%esp) */
-        .byte	0x8	/* .uleb128 0x8 */
-        .byte	0x85	/* DW_CFA_offset, column 0x5 %ebp at CFA + 2 * -4 */
-        .byte	0x2	/* .uleb128 0x2 */
-
-        .byte	0x4	/* DW_CFA_advance_loc4 */
-        .long	.LCFI1-.LCFI0
-        .byte	0xd	/* DW_CFA_def_cfa_register CFA = r5 = %ebp */
-        .byte	0x5	/* .uleb128 0x5 */
-
-        /* End of DW_CFA_xxx CFI instructions.  */
-        .align 4
-.LEFDE1:
-
-.LSFDE3:
-        .long	.LEFDE3-.LASFDE3	/* FDE Length */
-.LASFDE3:
-        .long	.LASFDE3-.Lframe1	/* FDE CIE offset */
-#if defined __PIC__ && defined HAVE_AS_X86_PCREL
-        .long	.LFB3-.	/* FDE initial location */
-#else
-        .long	.LFB3
-#endif
-        .long	.LFE3-.LFB3	/* FDE address range */
-#ifdef __PIC__
-        .byte	0x0	/* .uleb128 0x0; Augmentation size */
-#endif
-        /* DW_CFA_xxx CFI instructions go here.  */
-
-        .byte	0x4	/* DW_CFA_advance_loc4 */
-        .long	.LCFI4-.LFB3
-        .byte	0xe	/* DW_CFA_def_cfa_offset CFA = r4 + 8 = 8(%esp) */
-        .byte	0x8	/* .uleb128 0x8 */
-        .byte	0x85	/* DW_CFA_offset, column 0x5 %ebp at CFA + 2 * -4 */
-        .byte	0x2	/* .uleb128 0x2 */
-
-        .byte	0x4	/* DW_CFA_advance_loc4 */
-        .long	.LCFI5-.LCFI4
-        .byte	0xd	/* DW_CFA_def_cfa_register CFA = r5 = %ebp */
-        .byte	0x5	/* .uleb128 0x5 */
-
-        /* End of DW_CFA_xxx CFI instructions.  */
-        .align 4
-.LEFDE3:
-
-#if !FFI_NO_RAW_API
-
-.LSFDE4:
-        .long	.LEFDE4-.LASFDE4	/* FDE Length */
-.LASFDE4:
-        .long	.LASFDE4-.Lframe1	/* FDE CIE offset */
-#if defined __PIC__ && defined HAVE_AS_X86_PCREL
-        .long	.LFB4-.	/* FDE initial location */
-#else
-        .long	.LFB4
-#endif
-        .long	.LFE4-.LFB4	/* FDE address range */
-#ifdef __PIC__
-        .byte	0x0	/* .uleb128 0x0; Augmentation size */
-#endif
-        /* DW_CFA_xxx CFI instructions go here.  */
-
-        .byte	0x4	/* DW_CFA_advance_loc4 */
-        .long	.LCFI6-.LFB4
-        .byte	0xe	/* DW_CFA_def_cfa_offset CFA = r4 + 8 = 8(%esp) */
-        .byte	0x8	/* .uleb128 0x8 */
-        .byte	0x85	/* DW_CFA_offset, column 0x5 %ebp at CFA + 2 * -4 */
-        .byte	0x2	/* .uleb128 0x2 */
-
-        .byte	0x4	/* DW_CFA_advance_loc4 */
-        .long	.LCFI7-.LCFI6
-        .byte	0xd	/* DW_CFA_def_cfa_register CFA = r5 = %ebp */
-        .byte	0x5	/* .uleb128 0x5 */
-
-        .byte	0x4	/* DW_CFA_advance_loc4 */
-        .long	.LCFI8-.LCFI7
-        .byte	0x86	/* DW_CFA_offset, column 0x6 %esi at CFA + 3 * -4 */
-        .byte	0x3	/* .uleb128 0x3 */
-
-        /* End of DW_CFA_xxx CFI instructions.  */
-        .align 4
-.LEFDE4:
-
-#endif /* !FFI_NO_RAW_API */
-
-.LSFDE5:
-        .long	.LEFDE5-.LASFDE5	/* FDE Length */
-.LASFDE5:
-        .long	.LASFDE5-.Lframe1	/* FDE CIE offset */
-#if defined __PIC__ && defined HAVE_AS_X86_PCREL
-        .long	.LFB5-.	/* FDE initial location */
-#else
-        .long	.LFB5
-#endif
-        .long	.LFE5-.LFB5	/* FDE address range */
-#ifdef __PIC__
-        .byte	0x0	/* .uleb128 0x0; Augmentation size */
-#endif
-        /* DW_CFA_xxx CFI instructions go here.  */
-
-        .byte	0x4	/* DW_CFA_advance_loc4 */
-        .long	.LCFI9-.LFB5
-        .byte	0xe	/* DW_CFA_def_cfa_offset CFA = r4 + 8 = 8(%esp) */
-        .byte	0x8	/* .uleb128 0x8 */
-        .byte	0x85	/* DW_CFA_offset, column 0x5 %ebp at CFA + 2 * -4 */
-        .byte	0x2	/* .uleb128 0x2 */
-
-        .byte	0x4	/* DW_CFA_advance_loc4 */
-        .long	.LCFI10-.LCFI9
-        .byte	0xd	/* DW_CFA_def_cfa_register CFA = r5 = %ebp */
-        .byte	0x5	/* .uleb128 0x5 */
-
-        /* End of DW_CFA_xxx CFI instructions.  */
-        .align 4
-.LEFDE5:
-
-#endif /* !_MSC_VER */
-
-#if defined __ELF__ && defined __linux__
-        .section	.note.GNU-stack,"",@progbits
-#endif
