diff --git a/apply-hack.x86-64.S b/apply-hack.x86-64.S
new file mode 100644
index 00000000..8a6ab323
--- /dev/null
+++ b/apply-hack.x86-64.S
@@ -0,0 +1,61 @@
+/* Apply-hack.x86-64.S
+;
+; Copyright (c) 2008-2015, The CHICKEN Team
+; Copyright (c) 2007, Felix L. Winkelmann
+; All rights reserved.
+;
+; Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following
+; conditions are met:
+;
+;   Redistributions of source code must retain the above copyright notice, this list of conditions and the following
+;     disclaimer. 
+;   Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following
+;     disclaimer in the documentation and/or other materials provided with the distribution. 
+;   Neither the name of the author nor the names of its contributors may be used to endorse or promote
+;     products derived from this software without specific prior written permission. 
+;
+; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS
+; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+; AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+; CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+; CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+; SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+; OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+; POSSIBILITY OF SUCH DAMAGE.
+*/
+
+	.text
+
+	.globl _C_do_apply_hack
+#ifndef __APPLE__
+	.type _C_do_apply_hack, @function
+#endif
+
+_C_do_apply_hack:
+	subq $8, %rsp		/* force non-16 byte alignment */
+	movq %rdi, %r11		/* get proc */
+	movq %rsi, %r10		/* save buffer address, before we clobber %rsi */
+	cmpl $6, %edx		/* clamp at 6 */
+	ja l2
+	je l3
+	movq $6, %rbx		/* (6 - count) * 4 gives instruction address */
+	subq %rdx, %rbx
+	shlq $2, %rbx
+	lea l3(%rip), %rdx
+	addq %rdx, %rbx
+	jmp *%rbx
+l2:	lea 48(%r10), %rsp	/* %r10 must be 16-byte aligned at this point */
+l3:	movq 40(%r10), %r9      /* fill registers... */
+	movq 32(%r10), %r8
+	movq 24(%r10), %rcx
+	movq 16(%r10), %rdx
+	movq 8(%r10), %rsi
+	movq (%r10), %rdi
+	xorq %rax, %rax
+	call *%r11
+
+/* Set non-executable stack for Linux ELF target */
+#if defined(__ELF__)
+	.section .note.GNU-stack,"",%progbits
+#endif
diff --git a/dispatch-hack.c b/dispatch-hack.c
new file mode 100644
index 00000000..23a62404
--- /dev/null
+++ b/dispatch-hack.c
@@ -0,0 +1,69 @@
+
+#include "cyclone/types.h"
+#include "cyclone/runtime.h"
+
+#ifdef C_HACKED_APPLY
+# if defined(C_MACOSX) || defined(__MINGW32__) || defined(__CYGWIN__)
+extern void C_do_apply_hack(void *proc, C_word *args, int count) C_noret;
+# else
+extern void _C_do_apply_hack(void *proc, C_word *args, int count) C_noret;
+#  define C_do_apply_hack _C_do_apply_hack
+# endif
+#endif
+
+/*
+#ifdef C_HACKED_APPLY
+  C_word *buf = C_temporary_stack_limit;
+  void *proc;
+#endif
+
+  if(c < 4) C_bad_min_argc(c, 4);
+
+  if(C_immediatep(fn) || C_header_bits(fn) != C_CLOSURE_TYPE) {
+    barf(C_NOT_A_CLOSURE_ERROR, "apply", fn);
+  }
+
+  va_start(v, fn);
+
+  for(i = n; i > 1; --i) {
+    x = va_arg(v, C_word);
+#ifdef C_HACKED_APPLY
+    *(buf++) = x;
+#endif
+
+#ifdef C_HACKED_APPLY
+    if(buf >= C_temporary_stack_bottom) barf(C_TOO_MANY_PARAMETERS_ERROR, "apply");
+
+    *(buf++) = x;
+#else
+
+#ifdef C_HACKED_APPLY
+  // 3 additional args + 1 slot for stack-pointer + two for stack-alignment to 16 bytes 
+  buf = alloca((n + 6) * sizeof(C_word));
+# ifdef __x86_64__
+  // XXX Shouldn't this check for C_SIXTY_FOUR in general? 
+  buf = (void *)C_align16((C_uword)buf);
+# endif
+  buf[ 0 ] = n + 2;
+  buf[ 1 ] = fn;
+  buf[ 2 ] = k;
+  C_memcpy(&buf[ 3 ], C_temporary_stack_limit, n * sizeof(C_word));
+  proc = (void *)C_block_item(fn, 0);
+  C_do_apply_hack(proc, buf, n + 3);
+#else
+  C_do_apply(n, fn, k);
+#endif
+*/
+
+void do_dispatch(void *data, int argc, function_type func, object clo, object *b) {
+//  switch(argc) {case 0:func(data,0,clo);
+//case 1:func(data,1,clo,*(b+0));
+//
+//  default:
+//  {
+//   char buf[1024];
+//   snprintf(buf, 1023, "Unhandled number of function arguments: %d\n", argc); 
+//   Cyc_rt_raise_msg(data, buf);
+//  }
+//  }
+}