diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..baf0444
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,459 @@
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+		  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
diff --git a/Makefile.gbase b/Makefile.gbase
new file mode 100644
index 0000000..ad03d36
--- /dev/null
+++ b/Makefile.gbase
@@ -0,0 +1,248 @@
+#
+#  Copyright (C) 2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+
+# Makefile for libacml_mv library
+
+# What we're building, and where to find it.
+LIBRARY = libacml_mv.a
+
+TARGETS = $(LIBRARY)
+
+# Makefile setup
+include $(COMMONDEFS)
+
+VPATH    = $(BUILD_BASE)/src:$(BUILD_BASE)/src/gas
+
+# Compiler options
+LCOPTS = $(STD_COMPILE_OPTS) $(STD_C_OPTS)
+LCDEFS = $(HOSTDEFS) $(TARGDEFS)
+LCINCS = -I$(BUILD_BASE)/inc
+
+# CFLAGS += -Wall -W -Wstrict-prototypes -Werror -fPIC -O2 $(DEBUG)
+
+ifeq ($(BUILD_ARCH), X8664)
+
+CFILES = \
+	acos.c \
+	acosf.c \
+	acosh.c \
+	acoshf.c \
+	asin.c \
+	asinf.c \
+	asinh.c \
+	asinhf.c \
+	atan2.c \
+	atan2f.c \
+	atan.c \
+	atanf.c \
+	atanh.c \
+	atanhf.c \
+	ceil.c \
+	ceilf.c \
+	cosh.c \
+	coshf.c \
+	exp_special.c \
+	finite.c \
+	finitef.c \
+	floor.c \
+	floorf.c \
+	frexp.c \
+	frexpf.c \
+	hypot.c \
+	hypotf.c \
+	ilogb.c \
+	ilogbf.c \
+	ldexp.c \
+	ldexpf.c \
+	libm_special.c \
+	llrint.c \
+	llrintf.c \
+	llround.c \
+	llroundf.c \
+	log1p.c \
+	log1pf.c \
+	logb.c \
+	logbf.c \
+	log_special.c \
+	lrint.c \
+	lrintf.c \
+	lround.c \
+	lroundf.c \
+	modf.c \
+	modff.c \
+	nan.c \
+	nanf.c \
+	nearbyintf.c \
+	nextafter.c \
+	nextafterf.c \
+	nexttoward.c \
+	nexttowardf.c \
+	pow_special.c \
+	remainder_piby2.c \
+	remainder_piby2d2f.c \
+	rint.c \
+	rintf.c \
+	roundf.c \
+	scalbln.c \
+	scalblnf.c \
+	scalbn.c \
+	scalbnf.c \
+	sincos_special.c \
+	sinh.c \
+	sinhf.c \
+	sqrt.c \
+	sqrtf.c \
+	tan.c \
+	tanf.c \
+	tanh.c \
+	tanhf.c
+
+ASFILES = \
+	cbrtf.S \
+	cbrt.S \
+	copysignf.S \
+	copysign.S \
+	cosf.S \
+	cos.S \
+	exp10f.S \
+	exp10.S \
+	exp2f.S \
+	exp2.S \
+	expf.S \
+	expm1f.S \
+	expm1.S \
+	exp.S \
+	fabsf.S \
+	fabs.S \
+	fdimf.S \
+	fdim.S \
+	fmaxf.S \
+	fmax.S \
+	fminf.S \
+	fmin.S \
+	fmodf.S \
+	fmod.S \
+	log10f.S \
+	log10.S \
+	log2f.S \
+	log2.S \
+	logf.S \
+	log.S \
+	nearbyint.S \
+	powf.S \
+	pow.S \
+	remainderf.S \
+	remainder.S \
+	round.S \
+	sincosf.S \
+	sincos.S \
+	sinf.S \
+	sin.S \
+	truncf.S \
+	trunc.S \
+	v4hcosl.S \
+	v4helpl.S \
+	v4hfrcpal.S \
+	v4hlog10l.S \
+	v4hlog2l.S \
+	v4hlogl.S \
+	v4hsinl.S \
+	vrd2cos.S \
+	vrd2exp.S \
+	vrd2log10.S \
+	vrd2log2.S \
+	vrd2log.S \
+	vrd2sincos.S \
+	vrd2sin.S \
+	vrd4cos.S \
+	vrd4exp.S \
+	vrd4frcpa.S \
+	vrd4log10.S \
+	vrd4log2.S \
+	vrd4log.S \
+	vrd4sin.S \
+	vrdacos.S \
+	vrdaexp.S \
+	vrdalog10.S \
+	vrdalog2.S \
+	vrdalogr.S \
+	vrdalog.S \
+	vrda_scaled_logr.S \
+	vrda_scaledshifted_logr.S \
+	vrdasincos.S \
+	vrdasin.S \
+	vrs4cosf.S \
+	vrs4expf.S \
+	vrs4log10f.S \
+	vrs4log2f.S \
+	vrs4logf.S \
+	vrs4powf.S \
+	vrs4powxf.S \
+	vrs4sincosf.S \
+	vrs4sinf.S \
+	vrs8expf.S \
+	vrs8log10f.S \
+	vrs8log2f.S \
+	vrs8logf.S \
+	vrsacosf.S \
+	vrsaexpf.S \
+	vrsalog10f.S \
+	vrsalog2f.S \
+	vrsalogf.S \
+	vrsapowf.S \
+	vrsapowxf.S \
+	vrsasincosf.S \
+	vrsasinf.S
+
+else
+
+# The special processing of the -lm option in the compiler driver should
+# be delayed until all of the options have been parsed.  Until the
+# driver is cleaned up, it is important that processing be the same on
+# all architectures.  Thus we add an empty 32-bit ACML vector math
+# library.
+
+dummy.c :
+	echo "void libacml_mv_placeholder() {}" > dummy.c
+
+CFILES = dummy.c
+LDIRT += dummy.c
+
+endif
+
+
+default:
+	$(MAKE)  first
+	$(MAKE)  $(TARGETS)
+	$(MAKE)  last
+
+first : 
+ifndef SKIP_DEP_BUILD
+	$(call submake,$(BUILD_AREA)/include)
+endif
+
+last : make_libdeps
+
+include $(COMMONRULES)
+
+$(LIBRARY): $(OBJECTS)
+	$(ar) cru $@ $^
+	$(ranlib) $@
+
diff --git a/acml_trace.cc b/acml_trace.cc
new file mode 100644
index 0000000..b5c967f
--- /dev/null
+++ b/acml_trace.cc
@@ -0,0 +1,86 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+// Author: martint@google.com (Martin Thuresson)
+
+#include "third_party/open64_libacml_mv/acml_trace.h"
+
+#include <float.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <functional>
+#include <string>
+
+#include "base/commandlineflags.h"
+#include "base/examine_stack.h"
+#include "base/googleinit.h"
+#include "base/init_google.h"
+#include "base/logging.h"
+#include "file/base/file.h"
+#include "file/base/helpers.h"
+#include "testing/base/public/benchmark.h"
+#include "testing/base/public/googletest.h"
+#include "third_party/absl/strings/cord.h"
+#include "third_party/open64_libacml_mv/libacml.h"
+#include "util/task/status.h"
+
+template<typename T>
+std::unique_ptr<std::vector<T>> InitTrace(
+    const char* filename,
+    std::function<T(CordReader* reader)> callback) {
+  std::unique_ptr<std::vector<T>> trace(new std::vector<T>);
+  Cord cord;
+  CHECK_OK(file::GetContents(filename, &cord, file::Defaults()));
+  CordReader reader(cord);
+
+  while (!reader.done()) {
+    trace->push_back(callback(&reader));
+  }
+
+  return trace;
+}
+
+// Read a trace file with doubles.
+std::unique_ptr<std::vector<double>> GetTraceDouble(const char *filename) {
+  std::function<double(CordReader* reader)> read_double =
+      [](CordReader* reader) {
+    double d;
+    CHECK_GE(reader->Available(), sizeof(d));
+    reader->ReadN(sizeof(d), reinterpret_cast<char*>(&d));
+    return d;
+  };
+  std::unique_ptr<std::vector<double>> trace(InitTrace<double>(filename,
+                                                               read_double));
+  return trace;
+}
+
+// Read a trace file with pairs of doubles.
+std::unique_ptr<std::vector<std::pair<double, double>>> GetTraceDoublePair(
+    const char *filename) {
+  std::function<std::pair<double, double>(CordReader* reader)> read_double =
+      [](CordReader* reader) {
+    double d[2];
+    CHECK_GE(reader->Available(), sizeof(d));
+    reader->ReadN(sizeof(d), reinterpret_cast<char*>(&d));
+    return std::make_pair(d[0], d[1]);
+  };
+  std::unique_ptr<std::vector<std::pair<double, double>>> trace(
+      InitTrace<std::pair<double, double>>(filename, read_double));
+  return trace;
+}
+
+// Read a trace file with floats.
+std::unique_ptr<std::vector<float>> GetTraceFloat(const char *filename) {
+  std::function<float(CordReader* reader)> read_float =
+      [](CordReader* reader) {
+    float f;
+    const int bytes_to_read = min(sizeof(f), reader->Available());
+    reader->ReadN(bytes_to_read, reinterpret_cast<char*>(&f));
+    return f;
+  };
+  std::unique_ptr<std::vector<float>> trace(InitTrace<float>(filename,
+                                                             read_float));
+  return trace;
+}
diff --git a/acml_trace.h b/acml_trace.h
new file mode 100644
index 0000000..65eda94
--- /dev/null
+++ b/acml_trace.h
@@ -0,0 +1,25 @@
+// Copyright 2012 and onwards Google Inc.
+// Author: martint@google.com (Martin Thuresson)
+
+#ifndef THIRD_PARTY_OPEN64_LIBACML_MV_ACML_TRACE_H__
+#define THIRD_PARTY_OPEN64_LIBACML_MV_ACML_TRACE_H__
+
+// Log files gathered from a complete run of rephil/docs. Contains the
+// arguments to all exp/log/pow call.
+#define BASE_TRACE_PATH "google3/third_party/open64_libacml_mv/testdata/"
+#define EXP_LOGFILE (BASE_TRACE_PATH "/exp.rephil_docs.builtin.baseline.trace")
+#define EXPF_LOGFILE (BASE_TRACE_PATH "/expf.fastmath_unittest.trace")
+#define LOG_LOGFILE (BASE_TRACE_PATH "/log.rephil_docs.builtin.baseline.trace")
+#define POW_LOGFILE (BASE_TRACE_PATH "/pow.rephil_docs.builtin.baseline.trace")
+
+#include <memory>
+#include <vector>
+
+std::unique_ptr<std::vector<std::pair<double, double> >> GetTraceDoublePair(
+    const char *filename);
+
+std::unique_ptr<std::vector<double>> GetTraceDouble(const char *filename);
+
+std::unique_ptr<std::vector<float>> GetTraceFloat(const char *filename);
+
+#endif  // THIRD_PARTY_OPEN64_LIBACML_MV_ACML_TRACE_H__
diff --git a/acml_trace_benchmark.cc b/acml_trace_benchmark.cc
new file mode 100644
index 0000000..fb6acc4
--- /dev/null
+++ b/acml_trace_benchmark.cc
@@ -0,0 +1,272 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+// Author: martint@google.com (Martin Thuresson)
+
+#include "third_party/open64_libacml_mv/acml_trace.h"
+
+#include <float.h>
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <memory>
+#include <vector>
+
+#include "base/commandlineflags.h"
+#include "base/examine_stack.h"
+#include "base/googleinit.h"
+#include "base/init_google.h"
+#include "base/logging.h"
+#include "file/base/file.h"
+#include "file/base/path.h"
+#include "testing/base/public/benchmark.h"
+#include "testing/base/public/googletest.h"
+#include "third_party/open64_libacml_mv/libacml.h"
+
+
+int main(int argc, char** argv) {
+  InitGoogle(argv[0], &argc, &argv, true);
+  RunSpecifiedBenchmarks();
+  return 0;
+}
+
+namespace {
+
+// Local typedefs to avoid repeating complex types all over the function.
+typedef std::unique_ptr<std::vector<double>> DoubleListPtr;
+typedef std::unique_ptr<std::vector<float>> FloatListPtr;
+typedef std::unique_ptr<std::vector<std::pair<double,
+                                              double>>> DoublePairListPtr;
+
+/////////////////////////
+// Benchmark log() calls.
+/////////////////////////
+
+// Measure time spent iterating through the values.
+static void BM_math_trace_read_log(int iters) {
+  // Read trace file into memory.
+  StopBenchmarkTiming();
+  DoubleListPtr trace(GetTraceDouble(file::JoinPath(FLAGS_test_srcdir,
+                                                     LOG_LOGFILE).c_str()));
+  StartBenchmarkTiming();
+  // Process trace.
+  double d = 0.0;
+  for (int iter = 0; iter < iters; ++iter) {
+    for (auto iter = trace->begin(); iter != trace->end(); ++iter) {
+      d += *iter;
+    }
+  }
+  CHECK_NE(d, 0.0);
+}
+
+// Benchmark acml_log().
+static void BM_math_trace_acmllog(int iters) {
+  // Read trace file into memory.
+  StopBenchmarkTiming();
+  DoubleListPtr trace(GetTraceDouble(file::JoinPath(FLAGS_test_srcdir,
+                                                     LOG_LOGFILE).c_str()));
+  StartBenchmarkTiming();
+  double d = 0.0;
+  for (int iter = 0; iter < iters; ++iter) {
+    for (auto iter = trace->begin(); iter != trace->end(); ++iter) {
+      d += acml_log(*iter);
+    }
+  }
+  CHECK_NE(d, 0.0);
+}
+
+// Benchmark log().
+static void BM_math_trace_log(int iters) {
+  // Read trace file into memory.
+  StopBenchmarkTiming();
+  DoubleListPtr trace(GetTraceDouble(file::JoinPath(FLAGS_test_srcdir,
+                                                     LOG_LOGFILE).c_str()));
+  StartBenchmarkTiming();
+  double d = 0.0;
+  for (int iter = 0; iter < iters; ++iter) {
+    for (auto iter = trace->begin(); iter != trace->end(); ++iter) {
+      d += log(*iter);
+    }
+  }
+  CHECK_NE(d, 0.0);
+}
+
+
+/////////////////////////
+// Benchmark exp() calls.
+/////////////////////////
+
+// Measure time spent iterating through the values.
+static void BM_math_trace_read_exp(int iters) {
+  // Read trace file into memory.
+  StopBenchmarkTiming();
+  DoubleListPtr trace(GetTraceDouble(file::JoinPath(FLAGS_test_srcdir,
+                                                    EXP_LOGFILE).c_str()));
+  StartBenchmarkTiming();
+  double d = 0.0;
+  for (int iter = 0; iter < iters; ++iter) {
+    for (auto iter = trace->begin(); iter != trace->end(); ++iter) {
+      d += *iter;
+    }
+  }
+  CHECK_NE(d, 0.0);
+}
+
+// Benchmark acml_exp().
+static void BM_math_trace_acmlexp(int iters) {
+  // Read trace file into memory.
+  StopBenchmarkTiming();
+  DoubleListPtr trace(GetTraceDouble(file::JoinPath(FLAGS_test_srcdir,
+                                                    EXP_LOGFILE).c_str()));
+  StartBenchmarkTiming();
+  double d = 0.0;
+  for (int iter = 0; iter < iters; ++iter) {
+    for (auto iter = trace->begin(); iter != trace->end(); ++iter) {
+      d += acml_exp(*iter);
+    }
+  }
+  CHECK_NE(d, 0.0);
+}
+
+// Benchmark exp().
+static void BM_math_trace_exp(int iters) {
+  // Read trace file into memory.
+  StopBenchmarkTiming();
+  DoubleListPtr trace(GetTraceDouble(file::JoinPath(FLAGS_test_srcdir,
+                                                    EXP_LOGFILE).c_str()));
+  StartBenchmarkTiming();
+  double d = 0.0;
+  for (int iter = 0; iter < iters; ++iter) {
+    for (auto iter = trace->begin(); iter != trace->end(); ++iter) {
+      d += exp(*iter);
+    }
+  }
+  CHECK_NE(d, 0.0);
+}
+
+/////////////////////////
+// Benchmark expf() calls.
+/////////////////////////
+
+// Measure time spent iterating through the values.
+static void BM_math_trace_read_expf(int iters) {
+  // Read trace file into memory.
+  StopBenchmarkTiming();
+  FloatListPtr trace(GetTraceFloat(file::JoinPath(FLAGS_test_srcdir,
+                                                  EXPF_LOGFILE).c_str()));
+  StartBenchmarkTiming();
+  float d = 0.0;
+  for (int iter = 0; iter < iters; ++iter) {
+    for (auto iter = trace->begin(); iter != trace->end(); ++iter) {
+      d += *iter;
+    }
+  }
+  CHECK_NE(d, 0.0);
+}
+
+// Benchmark acml_exp().
+static void BM_math_trace_acmlexpf(int iters) {
+  // Read trace file into memory.
+  StopBenchmarkTiming();
+  FloatListPtr trace(GetTraceFloat(file::JoinPath(FLAGS_test_srcdir,
+                                                  EXPF_LOGFILE).c_str()));
+  StartBenchmarkTiming();
+  float d = 0.0;
+  for (int iter = 0; iter < iters; ++iter) {
+    for (auto iter = trace->begin(); iter != trace->end(); ++iter) {
+      d += acml_expf(*iter);
+    }
+  }
+  CHECK_NE(d, 0.0);
+}
+
+// Benchmark exp().
+static void BM_math_trace_expf(int iters) {
+  // Read trace file into memory.
+  StopBenchmarkTiming();
+  FloatListPtr trace(GetTraceFloat(file::JoinPath(FLAGS_test_srcdir,
+                                                  EXPF_LOGFILE).c_str()));
+  StartBenchmarkTiming();
+  float d = 0.0;
+  for (int iter = 0; iter < iters; ++iter) {
+    for (auto iter = trace->begin(); iter != trace->end(); ++iter) {
+      d += expf(*iter);
+    }
+  }
+  CHECK_NE(d, 0.0);
+}
+
+
+/////////////////////////
+// Benchmark pow() calls.
+/////////////////////////
+
+// Measure time spent iterating through the values.
+static void BM_math_trace_read_pow(int iters) {
+  // Read trace file into memory.
+  StopBenchmarkTiming();
+  DoublePairListPtr trace(GetTraceDoublePair(file::JoinPath(
+      FLAGS_test_srcdir, POW_LOGFILE).c_str()));
+  StartBenchmarkTiming();
+  double d = 0.0;
+  for (int iter = 0; iter < iters; ++iter) {
+    for (auto itr = trace->begin(); itr != trace->end(); ++itr) {
+      d += (*itr).first + (*itr).second;
+    }
+  }
+  CHECK_NE(d, 0.0);
+}
+
+// Benchmark acml_pow().
+static void BM_math_trace_acmlpow(int iters) {
+  // Read trace file into memory.
+  StopBenchmarkTiming();
+  DoublePairListPtr trace(GetTraceDoublePair(file::JoinPath(
+      FLAGS_test_srcdir, POW_LOGFILE).c_str()));
+  StartBenchmarkTiming();
+  double d = 0.0;
+  for (int iter = 0; iter < iters; ++iter) {
+    for (auto itr = trace->begin(); itr != trace->end(); ++itr) {
+      d += acml_pow((*itr).first,
+                    (*itr).second);
+    }
+  }
+  CHECK_NE(d, 0.0);
+}
+
+// Benchmark pow().
+static void BM_math_trace_pow(int iters) {
+  // Read trace file into memory.
+  StopBenchmarkTiming();
+  DoublePairListPtr trace(GetTraceDoublePair(file::JoinPath(
+      FLAGS_test_srcdir, POW_LOGFILE).c_str()));
+  StartBenchmarkTiming();
+  double d = 0.0;
+  for (int iter = 0; iter < iters; ++iter) {
+    for (auto itr = trace->begin(); itr != trace->end(); ++itr) {
+      d += pow((*itr).first,
+               (*itr).second);
+    }
+  }
+  CHECK_NE(d, 0.0);
+}
+
+
+BENCHMARK(BM_math_trace_read_exp);
+BENCHMARK(BM_math_trace_acmlexp);
+BENCHMARK(BM_math_trace_exp);
+
+BENCHMARK(BM_math_trace_read_log);
+BENCHMARK(BM_math_trace_acmllog);
+BENCHMARK(BM_math_trace_log);
+
+BENCHMARK(BM_math_trace_read_pow);
+BENCHMARK(BM_math_trace_acmlpow);
+BENCHMARK(BM_math_trace_pow);
+
+BENCHMARK(BM_math_trace_read_expf);
+BENCHMARK(BM_math_trace_acmlexpf);
+BENCHMARK(BM_math_trace_expf);
+
+}  // namespace
diff --git a/acml_trace_validate_test.cc b/acml_trace_validate_test.cc
new file mode 100644
index 0000000..9bd682c
--- /dev/null
+++ b/acml_trace_validate_test.cc
@@ -0,0 +1,114 @@
+// Copyright 2012 Google Inc. All Rights Reserved.
+// Author: martint@google.com (Martin Thuresson)
+
+#include "third_party/open64_libacml_mv/acml_trace.h"
+
+#include <math.h>
+#include <stdio.h>
+
+#include <memory>
+#include <vector>
+
+#include "base/commandlineflags.h"
+#include "base/examine_stack.h"
+#include "base/googleinit.h"
+#include "base/init_google.h"
+#include "base/logging.h"
+#include "file/base/file.h"
+#include "file/base/path.h"
+#include "testing/base/public/benchmark.h"
+#include "testing/base/public/googletest.h"
+#include "testing/base/public/gunit.h"
+#include "third_party/open64_libacml_mv/libacml.h"
+
+
+int main(int argc, char** argv) {
+  InitGoogle(argv[0], &argc, &argv, true);
+  RunSpecifiedBenchmarks();
+  return RUN_ALL_TESTS();
+}
+
+
+// Compare two doubles given a maximum unit of least precision (ULP).
+bool AlmostEqualDoubleUlps(double A, double B, int64 maxUlps) {
+  CHECK_EQ(sizeof(A), sizeof(maxUlps));
+  if (A == B)
+    return true;
+  int64 intDiff = std::abs(*(reinterpret_cast<int64*>(&A)) -
+                           *(reinterpret_cast<int64*>(&B)));
+  return intDiff <= maxUlps;
+}
+
+// Compare two floats given a maximum unit of least precision (ULP).
+bool AlmostEqualFloatUlps(float A, float B, int32 maxUlps) {
+  CHECK_EQ(sizeof(A), sizeof(maxUlps));
+  if (A == B)
+    return true;
+  int32 intDiff = abs(*(reinterpret_cast<int32*>(&A)) -
+                      *(reinterpret_cast<int32*>(&B)));
+  return intDiff <= maxUlps;
+}
+
+TEST(Case, LogTest) {
+  // Read trace file into memory.
+  std::unique_ptr<std::vector<double>> trace(
+      GetTraceDouble(file::JoinPath(FLAGS_test_srcdir,
+                                    LOG_LOGFILE).c_str()));
+  double d1;
+  double d2;
+  for (auto iter = trace->begin(); iter != trace->end(); ++iter) {
+    d1 = acml_log(*iter);
+    d2 = log(*iter);
+    // Make sure difference is at most 1 ULP.
+    EXPECT_TRUE(AlmostEqualDoubleUlps(d1, d2, 1));
+  }
+}
+
+TEST(Case, ExpTest) {
+  // Read trace file into memory.
+  std::unique_ptr<std::vector<double>> trace(
+      GetTraceDouble(file::JoinPath(FLAGS_test_srcdir,
+                                    EXP_LOGFILE).c_str()));
+  double d1;
+  double d2;
+  for (auto iter = trace->begin(); iter != trace->end(); ++iter) {
+    d1 = acml_exp(*iter);
+    d2 = exp(*iter);
+    // Make sure difference is at most 1 ULP.
+    EXPECT_TRUE(AlmostEqualDoubleUlps(d1, d2, 1));
+  }
+}
+
+
+TEST(Case, ExpfTest) {
+  // Read trace file into memory.
+  std::unique_ptr<std::vector<float>> trace(
+      GetTraceFloat(file::JoinPath(FLAGS_test_srcdir,
+                                   EXPF_LOGFILE).c_str()));
+  float f1;
+  float f2;
+  for (auto iter = trace->begin(); iter != trace->end(); ++iter) {
+    f1 = acml_expf(*iter);
+    f2 = expf(*iter);
+    // Make sure difference is at most 1 ULP.
+    EXPECT_TRUE(AlmostEqualFloatUlps(f1, f2, 1));
+  }
+}
+
+
+TEST(Case, PowTest) {
+  // Read trace file into memory.
+  std::unique_ptr<std::vector<std::pair<double, double>>> trace(
+      GetTraceDoublePair(file::JoinPath(FLAGS_test_srcdir,
+                                        POW_LOGFILE).c_str()));
+  double d1;
+  double d2;
+  for (auto iter = trace->begin(); iter != trace->end(); ++iter) {
+    d1 = acml_pow((*iter).first,
+                  (*iter).second);
+    d2 = pow((*iter).first,
+             (*iter).second);
+    // Make sure difference is at most 1 ULP.
+    EXPECT_TRUE(AlmostEqualDoubleUlps(d1, d2, 1));
+  }
+}
diff --git a/inc/acml_mv.h b/inc/acml_mv.h
new file mode 100644
index 0000000..49b7feb
--- /dev/null
+++ b/inc/acml_mv.h
@@ -0,0 +1,81 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+
+/* 
+** A header file defining the C prototypes for the fast/vector libm functions
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*
+** The scalar routines.
+*/
+double fastexp(double);
+double fastlog(double);
+double fastlog10(double);
+double fastlog2(double);
+double fastpow(double,double);
+double fastsin(double);
+double fastcos(double);
+void fastsincos(double , double *, double *);
+
+float fastexpf(float );
+float fastlogf(float );
+float fastlog10f(float );
+float fastlog2f(float );
+float fastpowf(float,float);
+float fastcosf(float );
+float fastsinf(float );
+void fastsincosf(float, float *,float *);
+
+
+/*
+** The array routines.
+*/
+void vrda_exp(int, double *, double *);
+void vrda_log(int, double *, double *);
+void vrda_log10(int, double *, double *);
+void vrda_log2(int, double *, double *);
+void vrda_sin(int, double *, double *);
+void vrda_cos(int, double *, double *);
+void vrda_sincos(int, double *, double *, double *);
+
+void vrsa_expf(int, float *, float *);
+void vrsa_logf(int, float *, float *);
+void vrsa_log10f(int, float *, float *);
+void vrsa_log2f(int, float *, float *);
+void vrsa_powf(int n, float *x, float *y, float *z);
+void vrsa_powxf(int n, float *x, float y, float *z);
+void vrsa_sinf(int, float *, float *);
+void vrsa_cosf(int, float *, float *);
+void vrsa_sincosf(int, float *, float *, float *);
+
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/inc/acml_mv_m128.h b/inc/acml_mv_m128.h
new file mode 100644
index 0000000..c783fe3
--- /dev/null
+++ b/inc/acml_mv_m128.h
@@ -0,0 +1,103 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+
+/* 
+** A header file defining the C prototypes for the fast/vector libm functions
+*/
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/*
+** The scalar routines.
+*/
+double fastexp(double);
+double fastlog(double);
+double fastlog10(double);
+double fastlog2(double);
+double fastpow(double,double);
+double fastsin(double);
+double fastcos(double);
+void fastsincos(double , double *, double *);
+
+float fastexpf(float );
+float fastlogf(float );
+float fastlog10f(float );
+float fastlog2f(float );
+float fastpowf(float,float);
+float fastcosf(float );
+float fastsinf(float );
+void fastsincosf(float, float *,float *);
+
+/*
+** The single vector routines.
+*/
+__m128d __vrd2_log(__m128d);
+__m128d __vrd2_exp(__m128d);
+__m128d __vrd2_log10(__m128d);
+__m128d __vrd2_log2(__m128d);
+__m128d __vrd2_sin(__m128d);
+__m128d __vrd2_cos(__m128d);
+void __vrd2_sincos(__m128d, __m128d *, __m128d *);
+
+__m128 __vrs4_expf(__m128);
+__m128 __vrs4_logf(__m128);
+__m128 __vrs4_log10f(__m128);
+__m128 __vrs4_log2f(__m128);
+__m128 __vrs4_powf(__m128,__m128);
+__m128 __vrs4_powxf(__m128 x,float y);
+__m128 __vrs4_sinf(__m128);
+__m128 __vrs4_cosf(__m128);
+void __vrs4_sincosf(__m128, __m128 *, __m128 *);
+
+
+/*
+** The array routines.
+*/
+void vrda_exp(int, double *, double *);
+void vrda_log(int, double *, double *);
+void vrda_log10(int, double *, double *);
+void vrda_log2(int, double *, double *);
+void vrda_sin(int, double *, double *);
+void vrda_cos(int, double *, double *);
+void vrda_sincos(int, double *, double *, double *);
+
+void vrsa_expf(int, float *, float *);
+void vrsa_logf(int, float *, float *);
+void vrsa_log10f(int, float *, float *);
+void vrsa_log2f(int, float *, float *);
+void vrsa_powf(int n, float *x, float *y, float *z);
+void vrsa_powxf(int n, float *x, float y, float *z);
+void vrsa_sinf(int, float *, float *);
+void vrsa_cosf(int, float *, float *);
+void vrsa_sincosf(int, float *, float *, float *);
+
+
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/inc/fn_macros.h b/inc/fn_macros.h
new file mode 100644
index 0000000..afc2f59
--- /dev/null
+++ b/inc/fn_macros.h
@@ -0,0 +1,47 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifndef __FN_MACROS_H__
+#define __FN_MACROS_H__
+
+#if defined(WINDOWS)
+#pragma warning( disable : 4985 )
+#define FN_PROTOTYPE(fn_name) acml_impl_##fn_name
+#else
+/* For Linux we prepend function names by a double underscore */
+#define ACML_CONCAT(x,y) x##y
+/* #define FN_PROTOTYPE(fn_name) concat(__,fn_name) */
+#define FN_PROTOTYPE(fn_name) ACML_CONCAT(acml_impl_,fn_name) /* commenting out previous line for build success, !!!!! REVISIT THIS SOON !!!!! */
+#endif
+
+
+#if defined(WINDOWS)
+#define weak_alias(name, aliasname) /* as nothing */
+#else
+/* Define ALIASNAME as a weak alias for NAME.
+   If weak aliases are not available, this defines a strong alias.  */
+#define weak_alias(name, aliasname) /* _weak_alias (name, aliasname) */ /* !!!!! REVISIT THIS SOON !!!!! */
+#define _weak_alias(name, aliasname) extern __typeof (name) aliasname __attribute__ ((weak, alias (#name))); 
+#endif
+
+#endif // __FN_MACROS_H__
diff --git a/inc/libm_amd.h b/inc/libm_amd.h
new file mode 100644
index 0000000..66cd46c
--- /dev/null
+++ b/inc/libm_amd.h
@@ -0,0 +1,225 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifndef LIBM_AMD_H_INCLUDED
+#define LIBM_AMD_H_INCLUDED 1
+
+#include <emmintrin.h>
+#include "acml_mv.h"
+#include "acml_mv_m128.h"
+
+#include "fn_macros.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+ double FN_PROTOTYPE(cbrt)(double x);
+ float FN_PROTOTYPE(cbrtf)(float x);
+
+ double FN_PROTOTYPE(fabs)(double x);
+ float FN_PROTOTYPE(fabsf)(float x);
+
+double FN_PROTOTYPE(acos)(double x);
+ float FN_PROTOTYPE(acosf)(float x);
+
+ double FN_PROTOTYPE(acosh)(double x);
+ float FN_PROTOTYPE(acoshf)(float x);
+
+ double FN_PROTOTYPE(asin)(double x);
+ float FN_PROTOTYPE(asinf)(float x);
+
+ double FN_PROTOTYPE( asinh)(double x);
+ float FN_PROTOTYPE(asinhf)(float x);
+
+ double FN_PROTOTYPE( atan)(double x);
+ float FN_PROTOTYPE(atanf)(float x);
+
+ double FN_PROTOTYPE( atanh)(double x);
+ float FN_PROTOTYPE(atanhf)(float x);
+
+ double FN_PROTOTYPE( atan2)(double x, double y);
+ float FN_PROTOTYPE(atan2f)(float x, float y);
+
+ double FN_PROTOTYPE( ceil)(double x);
+ float FN_PROTOTYPE(ceilf)(float x);
+
+
+ double FN_PROTOTYPE( cos)(double x);
+ float FN_PROTOTYPE(cosf)(float x);
+
+ double FN_PROTOTYPE( cosh)(double x);
+ float FN_PROTOTYPE(coshf)(float x);
+
+ double FN_PROTOTYPE( exp)(double x);
+ float FN_PROTOTYPE(expf)(float x);
+
+ double FN_PROTOTYPE( expm1)(double x);
+ float FN_PROTOTYPE(expm1f)(float x);
+
+ double FN_PROTOTYPE( exp2)(double x);
+ float FN_PROTOTYPE(exp2f)(float x);
+
+ double FN_PROTOTYPE( exp10)(double x);
+ float FN_PROTOTYPE(exp10f)(float x);
+
+
+ double FN_PROTOTYPE( fdim)(double x, double y);
+ float FN_PROTOTYPE(fdimf)(float x, float y);
+
+#ifdef WINDOWS
+ int FN_PROTOTYPE(finite)(double x);
+ int FN_PROTOTYPE(finitef)(float x);
+#else
+ int FN_PROTOTYPE(finite)(double x);
+ int FN_PROTOTYPE(finitef)(float x);
+#endif
+
+ double FN_PROTOTYPE( floor)(double x);
+ float FN_PROTOTYPE(floorf)(float x);
+
+ double FN_PROTOTYPE( fmax)(double x, double y);
+ float FN_PROTOTYPE(fmaxf)(float x, float y);
+
+ double FN_PROTOTYPE( fmin)(double x, double y);
+ float FN_PROTOTYPE(fminf)(float x, float y);
+
+ double FN_PROTOTYPE( fmod)(double x, double y);
+ float FN_PROTOTYPE(fmodf)(float x, float y);
+
+#ifdef WINDOWS
+ double FN_PROTOTYPE( hypot)(double x, double y);
+ float FN_PROTOTYPE(hypotf)(float x, float y);
+#else
+ double FN_PROTOTYPE( hypot)(double x, double y);
+ float FN_PROTOTYPE(hypotf)(float x, float y);
+#endif
+
+ float FN_PROTOTYPE(ldexpf)(float x, int exp);
+
+ double FN_PROTOTYPE(ldexp)(double x, int exp);
+
+ double FN_PROTOTYPE( log)(double x);
+ float FN_PROTOTYPE(logf)(float x);
+
+
+ float FN_PROTOTYPE(log2f)(float x);
+
+ double FN_PROTOTYPE( log10)(double x);
+ float FN_PROTOTYPE(log10f)(float x);
+
+
+ float FN_PROTOTYPE(log1pf)(float x);
+
+#ifdef WINDOWS
+ double FN_PROTOTYPE( logb)(double x);
+ float FN_PROTOTYPE(logbf)(float x);
+#else
+ double FN_PROTOTYPE( logb)(double x);
+ float FN_PROTOTYPE(logbf)(float x);
+#endif
+
+ double FN_PROTOTYPE( modf)(double x, double *iptr);
+ float FN_PROTOTYPE(modff)(float x, float *iptr);
+
+ double FN_PROTOTYPE( nextafter)(double x, double y);
+ float FN_PROTOTYPE(nextafterf)(float x, float y);
+
+ double FN_PROTOTYPE( pow)(double x, double y);
+ float FN_PROTOTYPE(powf)(float x, float y);
+
+double FN_PROTOTYPE( remainder)(double x, double y);
+ float FN_PROTOTYPE(remainderf)(float x, float y);
+
+ double FN_PROTOTYPE(sin)(double x);
+ float FN_PROTOTYPE(sinf)(float x);
+
+ void FN_PROTOTYPE(sincos)(double x, double *s, double *c);
+ void FN_PROTOTYPE(sincosf)(float x, float *s, float *c);
+
+ double FN_PROTOTYPE( sinh)(double x);
+ float FN_PROTOTYPE(sinhf)(float x);
+
+ double FN_PROTOTYPE( sqrt)(double x);
+ float FN_PROTOTYPE(sqrtf)(float x);
+
+ double FN_PROTOTYPE( tan)(double x);
+ float FN_PROTOTYPE(tanf)(float x);
+
+ double FN_PROTOTYPE( tanh)(double x);
+ float FN_PROTOTYPE(tanhf)(float x);
+
+ double FN_PROTOTYPE( trunc)(double x);
+ float FN_PROTOTYPE(truncf)(float x);
+
+ double FN_PROTOTYPE( log1p)(double x);
+ double FN_PROTOTYPE( log2)(double x);
+
+ double FN_PROTOTYPE(cosh)(double x);
+ float FN_PROTOTYPE(coshf)(float fx);
+
+ double FN_PROTOTYPE(frexp)(double value, int *exp);
+ float FN_PROTOTYPE(frexpf)(float value, int *exp);
+ int FN_PROTOTYPE(ilogb)(double x);
+ int FN_PROTOTYPE(ilogbf)(float x);
+
+ long long int FN_PROTOTYPE(llrint)(double x);
+ long long int FN_PROTOTYPE(llrintf)(float x);
+ long int FN_PROTOTYPE(lrint)(double x);
+ long int FN_PROTOTYPE(lrintf)(float x);
+ long int FN_PROTOTYPE(lround)(double d);
+ long int FN_PROTOTYPE(lroundf)(float f);
+ double  FN_PROTOTYPE(nan)(const char *tagp);
+ float  FN_PROTOTYPE(nanf)(const char *tagp);
+ float FN_PROTOTYPE(nearbyintf)(float x);
+ double FN_PROTOTYPE(nearbyint)(double x);
+ double FN_PROTOTYPE(nextafter)(double x, double y);
+ float FN_PROTOTYPE(nextafterf)(float x, float y);
+ double FN_PROTOTYPE(nexttoward)(double x, long double y);
+ float FN_PROTOTYPE(nexttowardf)(float x, long double y);
+ double FN_PROTOTYPE(rint)(double x);
+ float FN_PROTOTYPE(rintf)(float x);
+ float FN_PROTOTYPE(roundf)(float f);
+ double FN_PROTOTYPE(round)(double f);
+ double FN_PROTOTYPE(scalbln)(double x, long int n);
+ float FN_PROTOTYPE(scalblnf)(float x, long int n);
+ double FN_PROTOTYPE(scalbn)(double x, int n);
+ float FN_PROTOTYPE(scalbnf)(float x, int n);
+ long long int FN_PROTOTYPE(llroundf)(float f);
+ long long int FN_PROTOTYPE(llround)(double d);
+
+
+#ifdef WINDOWS
+ double FN_PROTOTYPE(copysign)(double x, double y);
+ float FN_PROTOTYPE(copysignf)(float x, float y);
+#else
+ double FN_PROTOTYPE(copysign)(double x, double y);
+ float FN_PROTOTYPE(copysignf)(float x, float y);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LIBM_AMD_H_INCLUDED */
diff --git a/inc/libm_errno_amd.h b/inc/libm_errno_amd.h
new file mode 100644
index 0000000..1e6b8b9
--- /dev/null
+++ b/inc/libm_errno_amd.h
@@ -0,0 +1,33 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifndef LIBM_ERRNO_AMD_H_INCLUDED
+#define LIBM_ERRNO_AMD_H_INCLUDED 1
+
+#include <stdio.h>
+#include <errno.h>
+#ifndef __set_errno
+#define __set_errno(x) errno = (x)
+#endif
+
+#endif /* LIBM_ERRNO_AMD_H_INCLUDED */
diff --git a/inc/libm_inlines_amd.h b/inc/libm_inlines_amd.h
new file mode 100644
index 0000000..a2e387a
--- /dev/null
+++ b/inc/libm_inlines_amd.h
@@ -0,0 +1,2188 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifndef LIBM_INLINES_AMD_H_INCLUDED
+#define LIBM_INLINES_AMD_H_INCLUDED 1
+
+#include "libm_util_amd.h"
+#include <math.h>
+
+#ifdef WINDOWS
+#define inline __inline
+#include "emmintrin.h"
+#endif
+
+/* Compile-time verification that type long is the same size
+   as type double (i.e. we are really on a 64-bit machine) */
+void check_long_against_double_size(int machine_is_64_bit[(sizeof(long long) == sizeof(double))?1:-1]); 
+
+/* Set defines for inline functions calling other inlines */
+#if defined(USE_VAL_WITH_FLAGS) || defined(USE_VALF_WITH_FLAGS) || \
+    defined(USE_ZERO_WITH_FLAGS) || defined(USE_ZEROF_WITH_FLAGS) || \
+    defined(USE_NAN_WITH_FLAGS) || defined(USE_NANF_WITH_FLAGS) || \
+    defined(USE_INDEFINITE_WITH_FLAGS) || defined(USE_INDEFINITEF_WITH_FLAGS) || \
+    defined(USE_INFINITY_WITH_FLAGS) || defined(USE_INFINITYF_WITH_FLAGS) || \
+    defined(USE_SQRT_AMD_INLINE) || defined(USE_SQRTF_AMD_INLINE) || \
+    (defined(WINDOWS) && (defined(USE_HANDLE_ERROR) || defined(USE_HANDLE_ERRORF)))
+#undef USE_RAISE_FPSW_FLAGS
+#define USE_RAISE_FPSW_FLAGS 1
+#endif
+
+#if defined(USE_SPLITDOUBLE)
+/* Splits double x into exponent e and mantissa m, where 0.5 <= abs(m) < 1.0.
+   Assumes that x is not zero, denormal, infinity or NaN, but these conditions
+   are not checked */
+static inline void splitDouble(double x, int *e, double *m)
+{
+  unsigned long long ux, uy;
+  GET_BITS_DP64(x, ux);
+  uy = ux;
+  ux &= EXPBITS_DP64;
+  ux >>= EXPSHIFTBITS_DP64;
+  *e = (int)ux - EXPBIAS_DP64 + 1;
+  uy = (uy & (SIGNBIT_DP64 | MANTBITS_DP64)) | HALFEXPBITS_DP64;
+  PUT_BITS_DP64(uy, x);
+  *m = x;
+}
+#endif /* USE_SPLITDOUBLE */
+
+
+#if defined(USE_SPLITDOUBLE_2)
+/* Splits double x into exponent e and mantissa m, where 1.0 <= abs(m) < 4.0.
+   Assumes that x is not zero, denormal, infinity or NaN, but these conditions
+   are not checked. Also assumes EXPBIAS_DP is odd. With this
+   assumption, e will be even on exit. */
+static inline void splitDouble_2(double x, int *e, double *m)
+{
+  unsigned long long ux, vx;
+  GET_BITS_DP64(x, ux);
+  vx = ux;
+  ux &= EXPBITS_DP64;
+  ux >>= EXPSHIFTBITS_DP64;
+  if (ux & 1)
+    {
+      /* The exponent is odd */
+      vx = (vx & (SIGNBIT_DP64 | MANTBITS_DP64)) | ONEEXPBITS_DP64;
+      PUT_BITS_DP64(vx, x);
+      *m = x;
+      *e = ux - EXPBIAS_DP64;
+    }
+  else
+    {
+      /* The exponent is even */
+      vx = (vx & (SIGNBIT_DP64 | MANTBITS_DP64)) | TWOEXPBITS_DP64;
+      PUT_BITS_DP64(vx, x);
+      *m = x;
+      *e = ux - EXPBIAS_DP64 - 1;
+    }
+}
+#endif /* USE_SPLITDOUBLE_2 */
+
+
+#if defined(USE_SPLITFLOAT)
+/* Splits float x into exponent e and mantissa m, where 0.5 <= abs(m) < 1.0.
+   Assumes that x is not zero, denormal, infinity or NaN, but these conditions
+   are not checked */
+static inline void splitFloat(float x, int *e, float *m)
+{
+  unsigned int ux, uy;
+  GET_BITS_SP32(x, ux);
+  uy = ux;
+  ux &= EXPBITS_SP32;
+  ux >>= EXPSHIFTBITS_SP32;
+  *e = (int)ux - EXPBIAS_SP32 + 1;
+  uy = (uy & (SIGNBIT_SP32 | MANTBITS_SP32)) | HALFEXPBITS_SP32;
+  PUT_BITS_SP32(uy, x);
+  *m = x;
+}
+#endif /* USE_SPLITFLOAT */
+
+
+#if defined(USE_SCALEDOUBLE_1)
+/* Scales the double x by 2.0**n.
+   Assumes EMIN <= n <= EMAX, though this condition is not checked. */
+static inline double scaleDouble_1(double x, int n)
+{
+  double t;
+  /* Construct the number t = 2.0**n */
+  PUT_BITS_DP64(((long long)n + EXPBIAS_DP64) << EXPSHIFTBITS_DP64, t);
+  return x*t;
+}
+#endif /* USE_SCALEDOUBLE_1 */
+
+
+#if defined(USE_SCALEDOUBLE_2)
+/* Scales the double x by 2.0**n.
+   Assumes 2*EMIN <= n <= 2*EMAX, though this condition is not checked. */
+static inline double scaleDouble_2(double x, int n)
+{
+  double t1, t2;
+  int n1, n2;
+  n1 = n / 2;
+  n2 = n - n1;
+  /* Construct the numbers t1 = 2.0**n1 and t2 = 2.0**n2 */
+  PUT_BITS_DP64(((long long)n1 + EXPBIAS_DP64) << EXPSHIFTBITS_DP64, t1);
+  PUT_BITS_DP64(((long long)n2 + EXPBIAS_DP64) << EXPSHIFTBITS_DP64, t2);
+  return (x*t1)*t2;
+}
+#endif /* USE_SCALEDOUBLE_2 */
+
+
+#if defined(USE_SCALEDOUBLE_3)
+/* Scales the double x by 2.0**n.
+   Assumes 3*EMIN <= n <= 3*EMAX, though this condition is not checked. */
+static inline double scaleDouble_3(double x, int n)
+{
+  double t1, t2, t3;
+  int n1, n2, n3;
+  n1 = n / 3;
+  n2 = (n - n1) / 2;
+  n3 = n - n1 - n2;
+  /* Construct the numbers t1 = 2.0**n1, t2 = 2.0**n2 and t3 = 2.0**n3 */
+  PUT_BITS_DP64(((long long)n1 + EXPBIAS_DP64) << EXPSHIFTBITS_DP64, t1);
+  PUT_BITS_DP64(((long long)n2 + EXPBIAS_DP64) << EXPSHIFTBITS_DP64, t2);
+  PUT_BITS_DP64(((long long)n3 + EXPBIAS_DP64) << EXPSHIFTBITS_DP64, t3);
+  return ((x*t1)*t2)*t3;
+}
+#endif /* USE_SCALEDOUBLE_3 */
+
+
+#if defined(USE_SCALEFLOAT_1)
+/* Scales the float x by 2.0**n.
+   Assumes EMIN <= n <= EMAX, though this condition is not checked. */
+static inline float scaleFloat_1(float x, int n)
+{
+  float t;
+  /* Construct the number t = 2.0**n */
+  PUT_BITS_SP32((n + EXPBIAS_SP32) << EXPSHIFTBITS_SP32, t);
+  return x*t;
+}
+#endif /* USE_SCALEFLOAT_1 */
+
+
+#if defined(USE_SCALEFLOAT_2)
+/* Scales the float x by 2.0**n.
+   Assumes 2*EMIN <= n <= 2*EMAX, though this condition is not checked. */
+static inline float scaleFloat_2(float x, int n)
+{
+  float t1, t2;
+  int n1, n2;
+  n1 = n / 2;
+  n2 = n - n1;
+  /* Construct the numbers t1 = 2.0**n1 and t2 = 2.0**n2 */
+  PUT_BITS_SP32((n1 + EXPBIAS_SP32) << EXPSHIFTBITS_SP32, t1);
+  PUT_BITS_SP32((n2 + EXPBIAS_SP32) << EXPSHIFTBITS_SP32, t2);
+  return (x*t1)*t2;
+}
+#endif /* USE_SCALEFLOAT_2 */
+
+
+#if defined(USE_SCALEFLOAT_3)
+/* Scales the float x by 2.0**n.
+   Assumes 3*EMIN <= n <= 3*EMAX, though this condition is not checked. */
+static inline float scaleFloat_3(float x, int n)
+{
+  float t1, t2, t3;
+  int n1, n2, n3;
+  n1 = n / 3;
+  n2 = (n - n1) / 2;
+  n3 = n - n1 - n2;
+  /* Construct the numbers t1 = 2.0**n1, t2 = 2.0**n2 and t3 = 2.0**n3 */
+  PUT_BITS_SP32((n1 + EXPBIAS_SP32) << EXPSHIFTBITS_SP32, t1);
+  PUT_BITS_SP32((n2 + EXPBIAS_SP32) << EXPSHIFTBITS_SP32, t2);
+  PUT_BITS_SP32((n3 + EXPBIAS_SP32) << EXPSHIFTBITS_SP32, t3);
+  return ((x*t1)*t2)*t3;
+}
+#endif /* USE_SCALEFLOAT_3 */
+
+#if defined(USE_SETPRECISIONDOUBLE)
+unsigned int setPrecisionDouble(void)
+{
+  unsigned int cw, cwold = 0;
+  /* There is no precision control on Hammer */
+  return cwold;
+}
+#endif /* USE_SETPRECISIONDOUBLE */
+
+#if defined(USE_RESTOREPRECISION)
+void restorePrecision(unsigned int cwold)
+{
+#if defined(WINDOWS)
+  /* There is no precision control on Hammer */
+#elif defined(linux)
+  /* There is no precision control on Hammer */
+#else
+#error Unknown machine
+#endif
+  return;
+}
+#endif /* USE_RESTOREPRECISION */
+
+
+#if defined(USE_CLEAR_FPSW_FLAGS)
+/* Clears floating-point status flags. The argument should be
+   the bitwise or of the flags to be cleared, from the
+   list above, e.g.
+     clear_fpsw_flags(AMD_F_INEXACT | AMD_F_INVALID);
+ */
+static inline void clear_fpsw_flags(int flags)
+{
+#if defined(WINDOWS)
+  unsigned int cw = _mm_getcsr();
+  cw &= (~flags);
+  _mm_setcsr(cw);
+#elif defined(linux)
+  unsigned int cw;
+  /* Get the current floating-point control/status word */
+  asm volatile ("STMXCSR %0" : "=m" (cw));
+  cw &= (~flags);
+  asm volatile ("LDMXCSR %0" : : "m" (cw));
+#else
+#error Unknown machine
+#endif
+}
+#endif /* USE_CLEAR_FPSW_FLAGS */
+
+
+#if defined(USE_RAISE_FPSW_FLAGS)
+/* Raises floating-point status flags. The argument should be
+   the bitwise or of the flags to be raised, from the
+   list above, e.g.
+     raise_fpsw_flags(AMD_F_INEXACT | AMD_F_INVALID);
+ */
+static inline void raise_fpsw_flags(int flags)
+{
+#if defined(WINDOWS)
+  _mm_setcsr(_mm_getcsr() | flags);
+#elif defined(linux)
+  unsigned int cw;
+  /* Get the current floating-point control/status word */
+  asm volatile ("STMXCSR %0" : "=m" (cw));
+  cw |= flags;
+  asm volatile ("LDMXCSR %0" : : "m" (cw));
+#else
+#error Unknown machine
+#endif
+}
+#endif /* USE_RAISE_FPSW_FLAGS */
+
+
+#if defined(USE_GET_FPSW_INLINE)
+/* Return the current floating-point status word */
+static inline unsigned int get_fpsw_inline(void)
+{
+#if defined(WINDOWS)
+  return _mm_getcsr();
+#elif defined(linux)
+  unsigned int sw;
+  asm volatile ("STMXCSR %0" : "=m" (sw));
+  return sw;
+#else
+#error Unknown machine
+#endif
+}
+#endif /* USE_GET_FPSW_INLINE */
+
+#if defined(USE_SET_FPSW_INLINE)
+/* Set the floating-point status word */
+static inline void set_fpsw_inline(unsigned int sw)
+{
+#if defined(WINDOWS)
+  _mm_setcsr(sw);
+#elif defined(linux)
+  /* Set the current floating-point control/status word */
+  asm volatile ("LDMXCSR %0" : : "m" (sw));
+#else
+#error Unknown machine
+#endif
+}
+#endif /* USE_SET_FPSW_INLINE */
+
+#if defined(USE_CLEAR_FPSW_INLINE)
+/* Clear all exceptions from the floating-point status word */
+static inline void clear_fpsw_inline(void)
+{
+#if defined(WINDOWS)
+  unsigned int cw;
+  cw = _mm_getcsr();
+  cw &= ~(AMD_F_INEXACT | AMD_F_UNDERFLOW | AMD_F_OVERFLOW |
+          AMD_F_DIVBYZERO | AMD_F_INVALID);
+  _mm_setcsr(cw);
+#elif defined(linux)
+  unsigned int cw;
+  /* Get the current floating-point control/status word */
+  asm volatile ("STMXCSR %0" : "=m" (cw));
+  cw &= ~(AMD_F_INEXACT | AMD_F_UNDERFLOW | AMD_F_OVERFLOW |
+          AMD_F_DIVBYZERO | AMD_F_INVALID);
+  asm volatile ("LDMXCSR %0" : : "m" (cw));
+#else
+#error Unknown machine
+#endif
+}
+#endif /* USE_CLEAR_FPSW_INLINE */
+
+
+#if defined(USE_VAL_WITH_FLAGS)
+/* Returns a double value after raising the given flags,
+  e.g.  val_with_flags(x, AMD_F_INEXACT);
+ */
+static inline double val_with_flags(double val, int flags)
+{
+  raise_fpsw_flags(flags);
+  return val;
+}
+#endif /* USE_VAL_WITH_FLAGS */
+
+#if defined(USE_VALF_WITH_FLAGS)
+/* Returns a float value after raising the given flags,
+  e.g.  valf_with_flags(x, AMD_F_INEXACT);
+ */
+static inline float valf_with_flags(float val, int flags)
+{
+  raise_fpsw_flags(flags);
+  return val;
+}
+#endif /* USE_VALF_WITH_FLAGS */
+
+
+#if defined(USE_ZERO_WITH_FLAGS)
+/* Returns a double +zero after raising the given flags,
+  e.g.  zero_with_flags(AMD_F_INEXACT | AMD_F_INVALID);
+ */
+static inline double zero_with_flags(int flags)
+{
+  raise_fpsw_flags(flags);
+  return 0.0;
+}
+#endif /* USE_ZERO_WITH_FLAGS */
+
+
+#if defined(USE_ZEROF_WITH_FLAGS)
+/* Returns a float +zero after raising the given flags,
+  e.g.  zerof_with_flags(AMD_F_INEXACT | AMD_F_INVALID);
+ */
+static inline float zerof_with_flags(int flags)
+{
+  raise_fpsw_flags(flags);
+  return 0.0F;
+}
+#endif /* USE_ZEROF_WITH_FLAGS */
+
+
+#if defined(USE_NAN_WITH_FLAGS)
+/* Returns a double quiet +nan after raising the given flags,
+   e.g.  nan_with_flags(AMD_F_INVALID);
+*/
+static inline double nan_with_flags(int flags)
+{
+  double z;
+  raise_fpsw_flags(flags);
+  PUT_BITS_DP64(0x7ff8000000000000, z);
+  return z;
+}
+#endif /* USE_NAN_WITH_FLAGS */
+
+#if defined(USE_NANF_WITH_FLAGS)
+/* Returns a float quiet +nan after raising the given flags,
+   e.g.  nanf_with_flags(AMD_F_INVALID);
+*/
+static inline float nanf_with_flags(int flags)
+{
+  float z;
+  raise_fpsw_flags(flags);
+  PUT_BITS_SP32(0x7fc00000, z);
+  return z;
+}
+#endif /* USE_NANF_WITH_FLAGS */
+
+
+#if defined(USE_INDEFINITE_WITH_FLAGS)
+/* Returns a double indefinite after raising the given flags,
+   e.g.  indefinite_with_flags(AMD_F_INVALID);
+*/
+static inline double indefinite_with_flags(int flags)
+{
+  double z;
+  raise_fpsw_flags(flags);
+  PUT_BITS_DP64(0xfff8000000000000, z);
+  return z;
+}
+#endif /* USE_INDEFINITE_WITH_FLAGS */
+
+#if defined(USE_INDEFINITEF_WITH_FLAGS)
+/* Returns a float quiet +indefinite after raising the given flags,
+   e.g.  indefinitef_with_flags(AMD_F_INVALID);
+*/
+static inline float indefinitef_with_flags(int flags)
+{
+  float z;
+  raise_fpsw_flags(flags);
+  PUT_BITS_SP32(0xffc00000, z);
+  return z;
+}
+#endif /* USE_INDEFINITEF_WITH_FLAGS */
+
+
+#ifdef USE_INFINITY_WITH_FLAGS
+/* Returns a positive double infinity after raising the given flags,
+   e.g.  infinity_with_flags(AMD_F_OVERFLOW);
+*/
+static inline double infinity_with_flags(int flags)
+{
+  double z;
+  raise_fpsw_flags(flags);
+  PUT_BITS_DP64((unsigned long long)(BIASEDEMAX_DP64 + 1) << EXPSHIFTBITS_DP64, z);
+  return z;
+}
+#endif /* USE_INFINITY_WITH_FLAGS */
+
+#ifdef USE_INFINITYF_WITH_FLAGS
+/* Returns a positive float infinity after raising the given flags,
+   e.g.  infinityf_with_flags(AMD_F_OVERFLOW);
+*/
+static inline float infinityf_with_flags(int flags)
+{
+  float z;
+  raise_fpsw_flags(flags);
+  PUT_BITS_SP32((BIASEDEMAX_SP32 + 1) << EXPSHIFTBITS_SP32, z);
+  return z;
+}
+#endif /* USE_INFINITYF_WITH_FLAGS */
+
+
+#if defined(USE_SPLITEXP)
+/* Compute the values m, z1, and z2 such that base**x = 2**m * (z1 + z2).
+   Small arguments abs(x) < 1/(16*ln(base)) and extreme arguments
+   abs(x) > large/(ln(base)) (where large is the largest representable
+   floating point number) should be handled separately instead of calling
+   this function. This function is called by exp_amd, exp2_amd, exp10_amd,
+   cosh_amd and sinh_amd. */
+static inline void splitexp(double x, double logbase,
+                            double thirtytwo_by_logbaseof2,
+                            double logbaseof2_by_32_lead,
+                            double logbaseof2_by_32_trail,
+                            int *m, double *z1, double *z2)
+{
+  double q, r, r1, r2, f1, f2;
+  int n, j;
+
+/* Arrays two_to_jby32_lead_table and two_to_jby32_trail_table contain
+   leading and trailing parts respectively of precomputed
+   values of pow(2.0,j/32.0), for j = 0, 1, ..., 31.
+   two_to_jby32_lead_table contains the first 25 bits of precision,
+   and two_to_jby32_trail_table contains a further 53 bits precision. */
+
+  static const double two_to_jby32_lead_table[32] = {
+    1.00000000000000000000e+00,   /* 0x3ff0000000000000 */
+    1.02189713716506958008e+00,   /* 0x3ff059b0d0000000 */
+    1.04427373409271240234e+00,   /* 0x3ff0b55860000000 */
+    1.06714040040969848633e+00,   /* 0x3ff11301d0000000 */
+    1.09050768613815307617e+00,   /* 0x3ff172b830000000 */
+    1.11438673734664916992e+00,   /* 0x3ff1d48730000000 */
+    1.13878858089447021484e+00,   /* 0x3ff2387a60000000 */
+    1.16372483968734741211e+00,   /* 0x3ff29e9df0000000 */
+    1.18920707702636718750e+00,   /* 0x3ff306fe00000000 */
+    1.21524733304977416992e+00,   /* 0x3ff371a730000000 */
+    1.24185776710510253906e+00,   /* 0x3ff3dea640000000 */
+    1.26905095577239990234e+00,   /* 0x3ff44e0860000000 */
+    1.29683953523635864258e+00,   /* 0x3ff4bfdad0000000 */
+    1.32523661851882934570e+00,   /* 0x3ff5342b50000000 */
+    1.35425549745559692383e+00,   /* 0x3ff5ab07d0000000 */
+    1.38390988111495971680e+00,   /* 0x3ff6247eb0000000 */
+    1.41421353816986083984e+00,   /* 0x3ff6a09e60000000 */
+    1.44518077373504638672e+00,   /* 0x3ff71f75e0000000 */
+    1.47682613134384155273e+00,   /* 0x3ff7a11470000000 */
+    1.50916439294815063477e+00,   /* 0x3ff8258990000000 */
+    1.54221081733703613281e+00,   /* 0x3ff8ace540000000 */
+    1.57598084211349487305e+00,   /* 0x3ff93737b0000000 */
+    1.61049032211303710938e+00,   /* 0x3ff9c49180000000 */
+    1.64575546979904174805e+00,   /* 0x3ffa5503b0000000 */
+    1.68179279565811157227e+00,   /* 0x3ffae89f90000000 */
+    1.71861928701400756836e+00,   /* 0x3ffb7f76f0000000 */
+    1.75625211000442504883e+00,   /* 0x3ffc199bd0000000 */
+    1.79470902681350708008e+00,   /* 0x3ffcb720d0000000 */
+    1.83400803804397583008e+00,   /* 0x3ffd5818d0000000 */
+    1.87416762113571166992e+00,   /* 0x3ffdfc9730000000 */
+    1.91520655155181884766e+00,   /* 0x3ffea4afa0000000 */
+    1.95714408159255981445e+00};  /* 0x3fff507650000000 */
+
+  static const double two_to_jby32_trail_table[32] = {
+    0.00000000000000000000e+00,   /* 0x0000000000000000 */
+    1.14890470981563546737e-08,   /* 0x3e48ac2ba1d73e2a */
+    4.83347014379782142328e-08,   /* 0x3e69f3121ec53172 */
+    2.67125131841396124714e-10,   /* 0x3df25b50a4ebbf1b */
+    4.65271045830351350190e-08,   /* 0x3e68faa2f5b9bef9 */
+    5.24924336638693782574e-09,   /* 0x3e368b9aa7805b80 */
+    5.38622214388600821910e-08,   /* 0x3e6ceac470cd83f6 */
+    1.90902301017041969782e-08,   /* 0x3e547f7b84b09745 */
+    3.79763538792174980894e-08,   /* 0x3e64636e2a5bd1ab */
+    2.69306947081946450986e-08,   /* 0x3e5ceaa72a9c5154 */
+    4.49683815095311756138e-08,   /* 0x3e682468446b6824 */
+    1.41933332021066904914e-09,   /* 0x3e18624b40c4dbd0 */
+    1.94146510233556266402e-08,   /* 0x3e54d8a89c750e5e */
+    2.46409119489264118569e-08,   /* 0x3e5a753e077c2a0f */
+    4.94812958044698886494e-08,   /* 0x3e6a90a852b19260 */
+    8.48872238075784476136e-10,   /* 0x3e0d2ac258f87d03 */
+    2.42032342089579394887e-08,   /* 0x3e59fcef32422cbf */
+    3.32420002333182569170e-08,   /* 0x3e61d8bee7ba46e2 */
+    1.45956577586525322754e-08,   /* 0x3e4f580c36bea881 */
+    3.46452721050003920866e-08,   /* 0x3e62999c25159f11 */
+    8.07090469079979051284e-09,   /* 0x3e415506dadd3e2a */
+    2.99439161340839520436e-09,   /* 0x3e29b8bc9e8a0388 */
+    9.83621719880452147153e-09,   /* 0x3e451f8480e3e236 */
+    8.35492309647188080486e-09,   /* 0x3e41f12ae45a1224 */
+    3.48493175137966283582e-08,   /* 0x3e62b5a75abd0e6a */
+    1.11084703472699692902e-08,   /* 0x3e47daf237553d84 */
+    5.03688744342840346564e-08,   /* 0x3e6b0aa538444196 */
+    4.81896001063495806249e-08,   /* 0x3e69df20d22a0798 */
+    4.83653666334089557746e-08,   /* 0x3e69f7490e4bb40b */
+    1.29745882314081237628e-08,   /* 0x3e4bdcdaf5cb4656 */
+    9.84532844621636118964e-09,   /* 0x3e452486cc2c7b9d */
+    4.25828404545651943883e-08};  /* 0x3e66dc8a80ce9f09 */
+
+    /*
+      Step 1. Reduce the argument.
+
+      To perform argument reduction, we find the integer n such that
+      x = n * logbaseof2/32 + remainder, |remainder| <= logbaseof2/64.
+      n is defined by round-to-nearest-integer( x*32/logbaseof2 ) and
+      remainder by x - n*logbaseof2/32. The calculation of n is
+      straightforward whereas the computation of x - n*logbaseof2/32
+      must be carried out carefully.
+      logbaseof2/32 is so represented in two pieces that
+      (1) logbaseof2/32 is known to extra precision, (2) the product
+      of n and the leading piece is a model number and is hence
+      calculated without error, and (3) the subtraction of the value
+      obtained in (2) from x is a model number and is hence again
+      obtained without error.
+    */
+
+    r = x * thirtytwo_by_logbaseof2;
+    /* Set n = nearest integer to r */
+    /* This is faster on Hammer */
+    if (r > 0)
+      n = (int)(r + 0.5);
+    else
+      n = (int)(r - 0.5);
+
+    r1 = x - n * logbaseof2_by_32_lead;
+    r2 =   - n * logbaseof2_by_32_trail;
+
+    /* Set j = n mod 32:   5 mod 32 = 5,   -5 mod 32 = 27,  etc. */
+    /* j = n % 32;
+       if (j < 0) j += 32; */
+    j = n & 0x0000001f;
+
+    f1 = two_to_jby32_lead_table[j];
+    f2 = two_to_jby32_trail_table[j];
+
+    *m = (n - j) / 32;
+
+    /* Step 2. The following is the core approximation. We approximate
+       exp(r1+r2)-1 by a polynomial. */
+
+    r1 *= logbase; r2 *= logbase;
+
+    r = r1 + r2;
+    q = r1 + (r2 +
+              r*r*( 5.00000000000000008883e-01 +
+                      r*( 1.66666666665260878863e-01 +
+                      r*( 4.16666666662260795726e-02 +
+                      r*( 8.33336798434219616221e-03 +
+                      r*( 1.38889490863777199667e-03 ))))));
+
+    /* Step 3. Function value reconstruction.
+       We now reconstruct the exponential of the input argument
+       so that exp(x) = 2**m * (z1 + z2).
+       The order of the computation below must be strictly observed. */
+
+    *z1 = f1;
+    *z2 = f2 + ((f1 + f2) * q);
+}
+#endif /* USE_SPLITEXP */
+
+
+#if defined(USE_SPLITEXPF)
+/* Compute the values m, z1, and z2 such that base**x = 2**m * (z1 + z2).
+   Small arguments abs(x) < 1/(16*ln(base)) and extreme arguments
+   abs(x) > large/(ln(base)) (where large is the largest representable
+   floating point number) should be handled separately instead of calling
+   this function. This function is called by exp_amd, exp2_amd, exp10_amd,
+   cosh_amd and sinh_amd. */
+static inline void splitexpf(float x, float logbase,
+                             float thirtytwo_by_logbaseof2,
+                             float logbaseof2_by_32_lead,
+                             float logbaseof2_by_32_trail,
+                             int *m, float *z1, float *z2)
+{
+  float q, r, r1, r2, f1, f2;
+  int n, j;
+
+/* Arrays two_to_jby32_lead_table and two_to_jby32_trail_table contain
+   leading and trailing parts respectively of precomputed
+   values of pow(2.0,j/32.0), for j = 0, 1, ..., 31.
+   two_to_jby32_lead_table contains the first 10 bits of precision,
+   and two_to_jby32_trail_table contains a further 24 bits precision. */
+
+  static const float two_to_jby32_lead_table[32] = {
+    1.0000000000E+00F,  /* 0x3F800000 */
+    1.0214843750E+00F,  /* 0x3F82C000 */
+    1.0429687500E+00F,  /* 0x3F858000 */
+    1.0664062500E+00F,  /* 0x3F888000 */
+    1.0898437500E+00F,  /* 0x3F8B8000 */
+    1.1132812500E+00F,  /* 0x3F8E8000 */
+    1.1386718750E+00F,  /* 0x3F91C000 */
+    1.1621093750E+00F,  /* 0x3F94C000 */
+    1.1875000000E+00F,  /* 0x3F980000 */
+    1.2148437500E+00F,  /* 0x3F9B8000 */
+    1.2402343750E+00F,  /* 0x3F9EC000 */
+    1.2675781250E+00F,  /* 0x3FA24000 */
+    1.2949218750E+00F,  /* 0x3FA5C000 */
+    1.3242187500E+00F,  /* 0x3FA98000 */
+    1.3535156250E+00F,  /* 0x3FAD4000 */
+    1.3828125000E+00F,  /* 0x3FB10000 */
+    1.4140625000E+00F,  /* 0x3FB50000 */
+    1.4433593750E+00F,  /* 0x3FB8C000 */
+    1.4765625000E+00F,  /* 0x3FBD0000 */
+    1.5078125000E+00F,  /* 0x3FC10000 */
+    1.5410156250E+00F,  /* 0x3FC54000 */
+    1.5742187500E+00F,  /* 0x3FC98000 */
+    1.6093750000E+00F,  /* 0x3FCE0000 */
+    1.6445312500E+00F,  /* 0x3FD28000 */
+    1.6816406250E+00F,  /* 0x3FD74000 */
+    1.7167968750E+00F,  /* 0x3FDBC000 */
+    1.7558593750E+00F,  /* 0x3FE0C000 */
+    1.7929687500E+00F,  /* 0x3FE58000 */
+    1.8339843750E+00F,  /* 0x3FEAC000 */
+    1.8730468750E+00F,  /* 0x3FEFC000 */
+    1.9140625000E+00F,  /* 0x3FF50000 */
+    1.9570312500E+00F}; /* 0x3FFA8000 */
+
+  static const float two_to_jby32_trail_table[32] = {
+    0.0000000000E+00F,  /* 0x00000000 */
+    4.1277357377E-04F,  /* 0x39D86988 */
+    1.3050324051E-03F,  /* 0x3AAB0D9F */
+    7.3415064253E-04F,  /* 0x3A407404 */
+    6.6398258787E-04F,  /* 0x3A2E0F1E */
+    1.1054925853E-03F,  /* 0x3A90E62D */
+    1.1675967835E-04F,  /* 0x38F4DCE0 */
+    1.6154836630E-03F,  /* 0x3AD3BEA3 */
+    1.7071149778E-03F,  /* 0x3ADFC146 */
+    4.0360994171E-04F,  /* 0x39D39B9C */
+    1.6234370414E-03F,  /* 0x3AD4C982 */
+    1.4728321694E-03F,  /* 0x3AC10C0C */
+    1.9176795613E-03F,  /* 0x3AFB5AA6 */
+    1.0178930825E-03F,  /* 0x3A856AD3 */
+    7.3992193211E-04F,  /* 0x3A41F752 */
+    1.0973819299E-03F,  /* 0x3A8FD607 */
+    1.5106226783E-04F,  /* 0x391E6678 */
+    1.8214319134E-03F,  /* 0x3AEEBD1D */
+    2.6364589576E-04F,  /* 0x398A39F4 */
+    1.3519275235E-03F,  /* 0x3AB13329 */
+    1.1952003697E-03F,  /* 0x3A9CA845 */
+    1.7620950239E-03F,  /* 0x3AE6F619 */
+    1.1153318919E-03F,  /* 0x3A923054 */
+    1.2242280645E-03F,  /* 0x3AA07647 */
+    1.5220546629E-04F,  /* 0x391F9958 */
+    1.8224230735E-03F,  /* 0x3AEEDE5F */
+    3.9278529584E-04F,  /* 0x39CDEEC0 */
+    1.7403248930E-03F,  /* 0x3AE41B9D */
+    2.3711356334E-05F,  /* 0x37C6E7C0 */
+    1.1207590578E-03F,  /* 0x3A92E66F */
+    1.1440613307E-03F,  /* 0x3A95F454 */
+    1.1287408415E-04F}; /* 0x38ECB6D0 */
+
+    /*
+      Step 1. Reduce the argument.
+
+      To perform argument reduction, we find the integer n such that
+      x = n * logbaseof2/32 + remainder, |remainder| <= logbaseof2/64.
+      n is defined by round-to-nearest-integer( x*32/logbaseof2 ) and
+      remainder by x - n*logbaseof2/32. The calculation of n is
+      straightforward whereas the computation of x - n*logbaseof2/32
+      must be carried out carefully.
+      logbaseof2/32 is so represented in two pieces that
+      (1) logbaseof2/32 is known to extra precision, (2) the product
+      of n and the leading piece is a model number and is hence
+      calculated without error, and (3) the subtraction of the value
+      obtained in (2) from x is a model number and is hence again
+      obtained without error.
+    */
+
+    r = x * thirtytwo_by_logbaseof2;
+    /* Set n = nearest integer to r */
+    /* This is faster on Hammer */
+    if (r > 0)
+      n = (int)(r + 0.5F);
+    else
+      n = (int)(r - 0.5F);
+
+    r1 = x - n * logbaseof2_by_32_lead;
+    r2 =   - n * logbaseof2_by_32_trail;
+
+    /* Set j = n mod 32:   5 mod 32 = 5,   -5 mod 32 = 27,  etc. */
+    /* j = n % 32;
+       if (j < 0) j += 32; */
+    j = n & 0x0000001f;
+
+    f1 = two_to_jby32_lead_table[j];
+    f2 = two_to_jby32_trail_table[j];
+
+    *m = (n - j) / 32;
+
+    /* Step 2. The following is the core approximation. We approximate
+       exp(r1+r2)-1 by a polynomial. */
+
+    r1 *= logbase; r2 *= logbase;
+
+    r = r1 + r2;
+    q = r1 + (r2 +
+              r*r*( 5.00000000000000008883e-01F +
+                      r*( 1.66666666665260878863e-01F )));
+
+    /* Step 3. Function value reconstruction.
+       We now reconstruct the exponential of the input argument
+       so that exp(x) = 2**m * (z1 + z2).
+       The order of the computation below must be strictly observed. */
+
+    *z1 = f1;
+    *z2 = f2 + ((f1 + f2) * q);
+}
+#endif /* SPLITEXPF */
+
+
+#if defined(USE_SCALEUPDOUBLE1024)
+/* Scales up a double (normal or denormal) whose bit pattern is given
+   as ux by 2**1024. There are no checks that the input number is
+   scalable by that amount. */
+static inline void scaleUpDouble1024(unsigned long long ux, unsigned long long *ur)
+{
+  unsigned long long uy;
+  double y;
+
+  if ((ux & EXPBITS_DP64) == 0)
+    {
+      /* ux is denormalised */
+      PUT_BITS_DP64(ux | 0x4010000000000000, y);
+      if (ux & SIGNBIT_DP64)
+        y += 4.0;
+      else
+        y -= 4.0;
+      GET_BITS_DP64(y, uy);
+    }
+  else
+    /* ux is normal */
+    uy = ux + 0x4000000000000000;
+
+  *ur = uy;
+  return;
+}
+
+#endif /* SCALEUPDOUBLE1024 */
+
+
+#if defined(USE_SCALEDOWNDOUBLE)
+/* Scales down a double whose bit pattern is given as ux by 2**k.
+   There are no checks that the input number is scalable by that amount. */
+static inline void scaleDownDouble(unsigned long long ux, int k,
+                                   unsigned long long *ur)
+{
+  unsigned long long uy, uk, ax, xsign;
+  int n, shift;
+  xsign = ux & SIGNBIT_DP64;
+  ax = ux & ~SIGNBIT_DP64;
+  n = (int)((ax & EXPBITS_DP64) >> EXPSHIFTBITS_DP64) - k;
+  if (n > 0)
+    {
+      uk = (unsigned long long)n << EXPSHIFTBITS_DP64;
+      uy = (ax & ~EXPBITS_DP64) | uk;
+    }
+  else
+    {
+      uy = (ax & ~EXPBITS_DP64) | 0x0010000000000000;
+      shift = (1 - n);
+      if (shift > MANTLENGTH_DP64 + 1)
+        /* Sigh. Shifting works mod 64 so be careful not to shift too much */
+        uy = 0;
+      else
+        {
+          /* Make sure we round the result */
+          uy >>= shift - 1;
+          uy = (uy >> 1) + (uy & 1);
+        }
+    }
+  *ur = uy | xsign;
+}
+
+#endif /* SCALEDOWNDOUBLE */
+
+
+#if defined(USE_SCALEUPFLOAT128)
+/* Scales up a float (normal or denormal) whose bit pattern is given
+   as ux by 2**128. There are no checks that the input number is
+   scalable by that amount. */
+static inline void scaleUpFloat128(unsigned int ux, unsigned int *ur)
+{
+  unsigned int uy;
+  float y;
+
+  if ((ux & EXPBITS_SP32) == 0)
+    {
+      /* ux is denormalised */
+      PUT_BITS_SP32(ux | 0x40800000, y);
+      /* Compensate for the implicit bit just added */
+      if (ux & SIGNBIT_SP32)
+        y += 4.0F;
+      else
+        y -= 4.0F;
+      GET_BITS_SP32(y, uy);
+    }
+  else
+    /* ux is normal */
+    uy = ux + 0x40000000;
+  *ur = uy;
+}
+#endif /* SCALEUPFLOAT128 */
+
+
+#if defined(USE_SCALEDOWNFLOAT)
+/* Scales down a float whose bit pattern is given as ux by 2**k.
+   There are no checks that the input number is scalable by that amount. */
+static inline void scaleDownFloat(unsigned int ux, int k,
+                                  unsigned int *ur)
+{
+  unsigned int uy, uk, ax, xsign;
+  int n, shift;
+
+  xsign = ux & SIGNBIT_SP32;
+  ax = ux & ~SIGNBIT_SP32;
+  n = ((ax & EXPBITS_SP32) >> EXPSHIFTBITS_SP32) - k;
+  if (n > 0)
+    {
+      uk = (unsigned int)n << EXPSHIFTBITS_SP32;
+      uy = (ax & ~EXPBITS_SP32) | uk;
+    }
+  else
+    {
+      uy = (ax & ~EXPBITS_SP32) | 0x00800000;
+      shift = (1 - n);
+      if (shift > MANTLENGTH_SP32 + 1)
+        /* Sigh. Shifting works mod 32 so be careful not to shift too much */
+        uy = 0;
+      else
+        {
+          /* Make sure we round the result */
+          uy >>= shift - 1;
+          uy = (uy >> 1) + (uy & 1);
+        }
+    }
+  *ur = uy | xsign;
+}
+#endif /* SCALEDOWNFLOAT */
+
+
+#if defined(USE_SQRT_AMD_INLINE)
+static inline double sqrt_amd_inline(double x)
+{
+  /*
+     Computes the square root of x.
+
+     The calculation is carried out in three steps.
+
+     Step 1. Reduction.
+     The input argument is scaled to the interval [1, 4) by
+     computing
+               x = 2^e * y, where y in [1,4).
+     Furthermore y is decomposed as y = c + t where
+               c = 1 + j/32, j = 0,1,..,96; and |t| <= 1/64.
+
+     Step 2. Approximation.
+     An approximation q = sqrt(1 + (t/c)) - 1  is obtained
+     from a basic series expansion using precomputed values
+     stored in rt_jby32_lead_table_dbl and rt_jby32_trail_table_dbl.
+
+     Step 3. Reconstruction.
+     The value of sqrt(x) is reconstructed via
+       sqrt(x) = 2^(e/2) * sqrt(y)
+               = 2^(e/2) * sqrt(c) * sqrt(y/c)
+               = 2^(e/2) * sqrt(c) * sqrt(1 + t/c)
+               = 2^(e/2) * [ sqrt(c) + sqrt(c)*q ]
+    */
+
+  unsigned long long ux, ax, u;
+  double r1, r2, c, y, p, q, r, twop, z, rtc, rtc_lead, rtc_trail;
+  int e, denorm = 0, index;
+
+/* Arrays rt_jby32_lead_table_dbl and rt_jby32_trail_table_dbl contain
+   leading and trailing parts respectively of precomputed
+   values of sqrt(j/32), for j = 32, 33, ..., 128.
+   rt_jby32_lead_table_dbl contains the first 21 bits of precision,
+   and rt_jby32_trail_table_dbl contains a further 53 bits precision. */
+
+  static const double rt_jby32_lead_table_dbl[97] = {
+    1.00000000000000000000e+00,   /* 0x3ff0000000000000 */
+    1.01550388336181640625e+00,   /* 0x3ff03f8100000000 */
+    1.03077602386474609375e+00,   /* 0x3ff07e0f00000000 */
+    1.04582500457763671875e+00,   /* 0x3ff0bbb300000000 */
+    1.06065940856933593750e+00,   /* 0x3ff0f87600000000 */
+    1.07528972625732421875e+00,   /* 0x3ff1346300000000 */
+    1.08972454071044921875e+00,   /* 0x3ff16f8300000000 */
+    1.10396957397460937500e+00,   /* 0x3ff1a9dc00000000 */
+    1.11803340911865234375e+00,   /* 0x3ff1e37700000000 */
+    1.13192272186279296875e+00,   /* 0x3ff21c5b00000000 */
+    1.14564323425292968750e+00,   /* 0x3ff2548e00000000 */
+    1.15920162200927734375e+00,   /* 0x3ff28c1700000000 */
+    1.17260360717773437500e+00,   /* 0x3ff2c2fc00000000 */
+    1.18585395812988281250e+00,   /* 0x3ff2f94200000000 */
+    1.19895744323730468750e+00,   /* 0x3ff32eee00000000 */
+    1.21191978454589843750e+00,   /* 0x3ff3640600000000 */
+    1.22474479675292968750e+00,   /* 0x3ff3988e00000000 */
+    1.23743629455566406250e+00,   /* 0x3ff3cc8a00000000 */
+    1.25000000000000000000e+00,   /* 0x3ff4000000000000 */
+    1.26243782043457031250e+00,   /* 0x3ff432f200000000 */
+    1.27475452423095703125e+00,   /* 0x3ff4656500000000 */
+    1.28695297241210937500e+00,   /* 0x3ff4975c00000000 */
+    1.29903793334960937500e+00,   /* 0x3ff4c8dc00000000 */
+    1.31101036071777343750e+00,   /* 0x3ff4f9e600000000 */
+    1.32287502288818359375e+00,   /* 0x3ff52a7f00000000 */
+    1.33463478088378906250e+00,   /* 0x3ff55aaa00000000 */
+    1.34629058837890625000e+00,   /* 0x3ff58a6800000000 */
+    1.35784721374511718750e+00,   /* 0x3ff5b9be00000000 */
+    1.36930561065673828125e+00,   /* 0x3ff5e8ad00000000 */
+    1.38066959381103515625e+00,   /* 0x3ff6173900000000 */
+    1.39194107055664062500e+00,   /* 0x3ff6456400000000 */
+    1.40312099456787109375e+00,   /* 0x3ff6732f00000000 */
+    1.41421318054199218750e+00,   /* 0x3ff6a09e00000000 */
+    1.42521858215332031250e+00,   /* 0x3ff6cdb200000000 */
+    1.43614006042480468750e+00,   /* 0x3ff6fa6e00000000 */
+    1.44697952270507812500e+00,   /* 0x3ff726d400000000 */
+    1.45773792266845703125e+00,   /* 0x3ff752e500000000 */
+    1.46841716766357421875e+00,   /* 0x3ff77ea300000000 */
+    1.47901916503906250000e+00,   /* 0x3ff7aa1000000000 */
+    1.48954677581787109375e+00,   /* 0x3ff7d52f00000000 */
+    1.50000000000000000000e+00,   /* 0x3ff8000000000000 */
+    1.51038074493408203125e+00,   /* 0x3ff82a8500000000 */
+    1.52068996429443359375e+00,   /* 0x3ff854bf00000000 */
+    1.53093051910400390625e+00,   /* 0x3ff87eb100000000 */
+    1.54110336303710937500e+00,   /* 0x3ff8a85c00000000 */
+    1.55120849609375000000e+00,   /* 0x3ff8d1c000000000 */
+    1.56124877929687500000e+00,   /* 0x3ff8fae000000000 */
+    1.57122516632080078125e+00,   /* 0x3ff923bd00000000 */
+    1.58113861083984375000e+00,   /* 0x3ff94c5800000000 */
+    1.59099006652832031250e+00,   /* 0x3ff974b200000000 */
+    1.60078048706054687500e+00,   /* 0x3ff99ccc00000000 */
+    1.61051177978515625000e+00,   /* 0x3ff9c4a800000000 */
+    1.62018489837646484375e+00,   /* 0x3ff9ec4700000000 */
+    1.62979984283447265625e+00,   /* 0x3ffa13a900000000 */
+    1.63935947418212890625e+00,   /* 0x3ffa3ad100000000 */
+    1.64886283874511718750e+00,   /* 0x3ffa61be00000000 */
+    1.65831184387207031250e+00,   /* 0x3ffa887200000000 */
+    1.66770744323730468750e+00,   /* 0x3ffaaeee00000000 */
+    1.67705059051513671875e+00,   /* 0x3ffad53300000000 */
+    1.68634128570556640625e+00,   /* 0x3ffafb4100000000 */
+    1.69558238983154296875e+00,   /* 0x3ffb211b00000000 */
+    1.70477199554443359375e+00,   /* 0x3ffb46bf00000000 */
+    1.71391296386718750000e+00,   /* 0x3ffb6c3000000000 */
+    1.72300529479980468750e+00,   /* 0x3ffb916e00000000 */
+    1.73204994201660156250e+00,   /* 0x3ffbb67a00000000 */
+    1.74104785919189453125e+00,   /* 0x3ffbdb5500000000 */
+    1.75000000000000000000e+00,   /* 0x3ffc000000000000 */
+    1.75890541076660156250e+00,   /* 0x3ffc247a00000000 */
+    1.76776695251464843750e+00,   /* 0x3ffc48c600000000 */
+    1.77658367156982421875e+00,   /* 0x3ffc6ce300000000 */
+    1.78535652160644531250e+00,   /* 0x3ffc90d200000000 */
+    1.79408740997314453125e+00,   /* 0x3ffcb49500000000 */
+    1.80277538299560546875e+00,   /* 0x3ffcd82b00000000 */
+    1.81142139434814453125e+00,   /* 0x3ffcfb9500000000 */
+    1.82002735137939453125e+00,   /* 0x3ffd1ed500000000 */
+    1.82859230041503906250e+00,   /* 0x3ffd41ea00000000 */
+    1.83711719512939453125e+00,   /* 0x3ffd64d500000000 */
+    1.84560203552246093750e+00,   /* 0x3ffd879600000000 */
+    1.85404872894287109375e+00,   /* 0x3ffdaa2f00000000 */
+    1.86245727539062500000e+00,   /* 0x3ffdcca000000000 */
+    1.87082862854003906250e+00,   /* 0x3ffdeeea00000000 */
+    1.87916183471679687500e+00,   /* 0x3ffe110c00000000 */
+    1.88745784759521484375e+00,   /* 0x3ffe330700000000 */
+    1.89571857452392578125e+00,   /* 0x3ffe54dd00000000 */
+    1.90394306182861328125e+00,   /* 0x3ffe768d00000000 */
+    1.91213226318359375000e+00,   /* 0x3ffe981800000000 */
+    1.92028617858886718750e+00,   /* 0x3ffeb97e00000000 */
+    1.92840576171875000000e+00,   /* 0x3ffedac000000000 */
+    1.93649101257324218750e+00,   /* 0x3ffefbde00000000 */
+    1.94454288482666015625e+00,   /* 0x3fff1cd900000000 */
+    1.95256233215332031250e+00,   /* 0x3fff3db200000000 */
+    1.96054744720458984375e+00,   /* 0x3fff5e6700000000 */
+    1.96850109100341796875e+00,   /* 0x3fff7efb00000000 */
+    1.97642326354980468750e+00,   /* 0x3fff9f6e00000000 */
+    1.98431301116943359375e+00,   /* 0x3fffbfbf00000000 */
+    1.99217128753662109375e+00,   /* 0x3fffdfef00000000 */
+    2.00000000000000000000e+00};  /* 0x4000000000000000 */
+
+  static const double rt_jby32_trail_table_dbl[97] = {
+    0.00000000000000000000e+00,   /* 0x0000000000000000 */
+    9.17217678638807524014e-07,   /* 0x3eaec6d70177881c */
+    3.82539669043705364790e-07,   /* 0x3e99abfb41bd6b24 */
+    2.85899577162227138140e-08,   /* 0x3e5eb2bf6bab55a2 */
+    7.63210485349101216659e-07,   /* 0x3ea99bed9b2d8d0c */
+    9.32123004127716212874e-07,   /* 0x3eaf46e029c1b296 */
+    1.95174719169309219157e-07,   /* 0x3e8a3226fc42f30c */
+    5.34316371481845492427e-07,   /* 0x3ea1edbe20701d73 */
+    5.79631242504454563052e-07,   /* 0x3ea372fe94f82be7 */
+    4.20404384109571705948e-07,   /* 0x3e9c367e08e7bb06 */
+    6.89486030314147010716e-07,   /* 0x3ea722a3d0a66608 */
+    6.89927685625314560328e-07,   /* 0x3ea7266f067ca1d6 */
+    3.32778123013641425828e-07,   /* 0x3e965515a9b34850 */
+    1.64433259436999584387e-07,   /* 0x3e8611e23ef6c1bd */
+    4.37590875197899335723e-07,   /* 0x3e9d5dc1059ed8e7 */
+    1.79808183816018617413e-07,   /* 0x3e88222982d0e4f4 */
+    7.46386593615986477624e-08,   /* 0x3e7409212e7d0322 */
+    5.72520794105201454728e-07,   /* 0x3ea335ea8a5fcf39 */
+    0.00000000000000000000e+00,   /* 0x0000000000000000 */
+    2.96860689431670420344e-07,   /* 0x3e93ec071e938bfe */
+    3.54167239176257065345e-07,   /* 0x3e97c48bfd9862c6 */
+    7.95211265664474710063e-07,   /* 0x3eaaaed010f74671 */
+    1.72327048595145565621e-07,   /* 0x3e87211cbfeb62e0 */
+    6.99494915996239297020e-07,   /* 0x3ea7789d9660e72d */
+    6.32644111701500844315e-07,   /* 0x3ea53a5f1d36f1cf */
+    6.20124838851440463844e-10,   /* 0x3e054eacff2057dc */
+    6.13404719757812629969e-07,   /* 0x3ea4951b3e6a83cc */
+    3.47654909777986407387e-07,   /* 0x3e9754aa76884c66 */
+    7.83106177002392475763e-07,   /* 0x3eaa46d4b1de1074 */
+    5.33337372440526357008e-07,   /* 0x3ea1e55548f92635 */
+    2.01508648555298681765e-08,   /* 0x3e55a3070dd17788 */
+    5.25472356925843939587e-07,   /* 0x3ea1a1c5eedb0801 */
+    3.81831102861301692797e-07,   /* 0x3e999fcef32422cc */
+    6.99220602161420018738e-07,   /* 0x3ea776425d6b0199 */
+    6.01209702477462624811e-07,   /* 0x3ea42c5a1e0191a2 */
+    9.01437000591944740554e-08,   /* 0x3e7832a0bdff1327 */
+    5.10428680864685379950e-08,   /* 0x3e6b674743636676 */
+    3.47895267104621031421e-07,   /* 0x3e9758cb90d2f714 */
+    7.80735841510641848628e-07,   /* 0x3eaa3278459cde25 */
+    1.35158752025506517690e-07,   /* 0x3e822404f4a103ee */
+    0.00000000000000000000e+00,   /* 0x0000000000000000 */
+    1.76523947728535489812e-09,   /* 0x3e1e539af6892ac5 */
+    6.68280121328499932183e-07,   /* 0x3ea66c7b872c9cd0 */
+    5.70135482405123276616e-07,   /* 0x3ea3216d2f43887d */
+    1.37705134737562525897e-07,   /* 0x3e827b832cbedc0e */
+    7.09655107074516613672e-07,   /* 0x3ea7cfe41579091d */
+    7.20302724551461693011e-07,   /* 0x3ea82b5a713c490a */
+    4.69926266058212796694e-07,   /* 0x3e9f8945932d872e */
+    2.19244345915999437026e-07,   /* 0x3e8d6d2da9490251 */
+    1.91141411617401877927e-07,   /* 0x3e89a791a3114e4a */
+    5.72297665296622053774e-07,   /* 0x3ea333ffe005988d */
+    5.61055484436830560103e-07,   /* 0x3ea2d36e0ed49ab1 */
+    2.76225500213991506100e-07,   /* 0x3e92898498f55f9e */
+    7.58466189522395692908e-07,   /* 0x3ea9732cca1032a3 */
+    1.56893371256836029827e-07,   /* 0x3e850ed0b02a22d2 */
+    4.06038997708867066507e-07,   /* 0x3e9b3fb265b1e40a */
+    5.51305629612057435809e-07,   /* 0x3ea27fade682d1de */
+    5.64778487026561123207e-07,   /* 0x3ea2f36906f707ba */
+    3.92609705553556897517e-07,   /* 0x3e9a58fbbee883b6 */
+    9.09698438776943827802e-07,   /* 0x3eae864005bca6d7 */
+    1.05949774066016139743e-07,   /* 0x3e7c70d02300f263 */
+    7.16578798392844784244e-07,   /* 0x3ea80b5d712d8e3e */
+    6.86233073531233972561e-07,   /* 0x3ea706b27cc7d390 */
+    7.99211473033494452908e-07,   /* 0x3eaad12c9d849a97 */
+    8.65552275731027456121e-07,   /* 0x3ead0b09954e764b */
+    6.75456120386058448618e-07,   /* 0x3ea6aa1fb7826cbd */
+    0.00000000000000000000e+00,   /* 0x0000000000000000 */
+    4.99167184520462138743e-07,   /* 0x3ea0bfd03f46763c */
+    4.51720373502110930296e-10,   /* 0x3dff0abfb4adfb9e */
+    1.28874162718371367439e-07,   /* 0x3e814c151f991b2e */
+    5.85529267186999798656e-07,   /* 0x3ea3a5a879b09292 */
+    1.01827770937125531924e-07,   /* 0x3e7b558d173f9796 */
+    2.54736389177809626508e-07,   /* 0x3e9118567cd83fb8 */
+    6.98925535290464831294e-07,   /* 0x3ea773b981896751 */
+    1.20940735036524314513e-07,   /* 0x3e803b7df49f48a8 */
+    5.43759351196479689657e-08,   /* 0x3e6d315f22491900 */
+    1.11957989042397958409e-07,   /* 0x3e7e0db1c5bb84b2 */
+    8.47006714134442661218e-07,   /* 0x3eac6bbb7644ff76 */
+    8.92831044643427836228e-07,   /* 0x3eadf55c3afec01f */
+    7.77828292464916501663e-07,   /* 0x3eaa197e81034da3 */
+    6.48469316302918797451e-08,   /* 0x3e71683f4920555d */
+    2.12579816658859849140e-07,   /* 0x3e8c882fd78bb0b0 */
+    7.61222472580559138435e-07,   /* 0x3ea98ad9eb7b83ec */
+    2.86488961857314189607e-07,   /* 0x3e9339d7c7777273 */
+    2.14637363790165363515e-07,   /* 0x3e8ccee237cae6fe */
+    5.44137005612605847831e-08,   /* 0x3e6d368fe324a146 */
+    2.58378284856442408413e-07,   /* 0x3e9156e7b6d99b45 */
+    3.15848939061134843091e-07,   /* 0x3e95323e5310b5c1 */
+    6.60530466255089632309e-07,   /* 0x3ea629e9db362f5d */
+    7.63436345535852301127e-07,   /* 0x3ea99dde4728d7ec */
+    8.68233432860324345268e-08,   /* 0x3e774e746878544d */
+    9.45465175398023087082e-07,   /* 0x3eafb97be873a87d */
+    8.77499534786171267246e-07,   /* 0x3ead71a9e23c2f63 */
+    2.74055432394999316135e-07,   /* 0x3e92643c89cda173 */
+    4.72129009349126213532e-07,   /* 0x3e9faf1d57a4d56c */
+    8.93777032327078947306e-07,   /* 0x3eadfd7c7ab7b282 */
+    0.00000000000000000000e+00};  /* 0x0000000000000000 */
+
+
+  /* Handle special arguments first */
+
+  GET_BITS_DP64(x, ux);
+  ax = ux & (~SIGNBIT_DP64);
+
+  if(ax >= 0x7ff0000000000000)
+    {
+      /* x is either NaN or infinity */
+      if (ux & MANTBITS_DP64)
+        /* x is NaN */
+        return x + x; /* Raise invalid if it is a signalling NaN */
+      else if (ux & SIGNBIT_DP64)
+        /* x is negative infinity */
+        return nan_with_flags(AMD_F_INVALID);
+      else
+        /* x is positive infinity */
+        return x;
+    }
+  else if (ux & SIGNBIT_DP64)
+    {
+      /* x is negative. */
+      if (ux == SIGNBIT_DP64)
+        /* Handle negative zero first */
+        return x;
+      else
+        return nan_with_flags(AMD_F_INVALID);
+    }
+  else if (ux <= 0x000fffffffffffff)
+    {
+      /* x is denormalised or zero */
+      if (ux == 0)
+        /* x is zero */
+        return x;
+      else
+        {
+          /* x is denormalised; scale it up */
+          /* Normalize x by increasing the exponent by 60
+             and subtracting a correction to account for the implicit
+             bit. This replaces a slow denormalized
+             multiplication by a fast normal subtraction. */
+          static const double corr = 2.5653355008114851558350183e-290; /* 0x03d0000000000000 */
+          denorm = 1;
+          GET_BITS_DP64(x, ux);
+          PUT_BITS_DP64(ux | 0x03d0000000000000, x);
+          x -= corr;
+          GET_BITS_DP64(x, ux);
+        }
+    }
+
+  /* Main algorithm */
+
+  /*
+     Find y and e such that x = 2^e * y, where y in [1,4).
+     This is done using an in-lined variant of splitDouble,
+     which also ensures that e is even.
+   */
+  y = x;
+  ux &= EXPBITS_DP64;
+  ux >>= EXPSHIFTBITS_DP64;
+  if (ux & 1)
+    {
+      GET_BITS_DP64(y, u);
+      u &= (SIGNBIT_DP64 | MANTBITS_DP64);
+      u |= ONEEXPBITS_DP64;
+      PUT_BITS_DP64(u, y);
+      e = ux - EXPBIAS_DP64;
+    }
+  else
+    {
+      GET_BITS_DP64(y, u);
+      u &= (SIGNBIT_DP64 | MANTBITS_DP64);
+      u |= TWOEXPBITS_DP64;
+      PUT_BITS_DP64(u, y);
+      e = ux - EXPBIAS_DP64 - 1;
+    }
+
+
+  /* Find the index of the sub-interval of [1,4) in which y lies. */
+
+  index = (int)(32.0*y+0.5);
+
+  /* Look up the table values and compute c and r = c/t */
+
+  rtc_lead = rt_jby32_lead_table_dbl[index-32];
+  rtc_trail = rt_jby32_trail_table_dbl[index-32];
+  c = 0.03125*index;
+  r = (y - c)/c;
+
+  /*
+    Find q = sqrt(1+r) - 1.
+    From one step of Newton on (q+1)^2 = 1+r
+  */
+
+  p = r*0.5 - r*r*(0.1250079870 - r*(0.6250522999E-01));
+  twop = p + p;
+  q = p - (p*p + (twop - r))/(twop + 2.0);
+
+  /* Reconstruction */
+
+  rtc = rtc_lead + rtc_trail;
+  e >>= 1; /* e = e/2 */
+  z = rtc_lead + (rtc*q+rtc_trail);
+
+  if (denorm)
+    {
+      /* Scale by 2**(e-30) */
+      PUT_BITS_DP64(((long long)(e - 30) + EXPBIAS_DP64) << EXPSHIFTBITS_DP64, r);
+      z *= r;
+    }
+  else
+    {
+      /* Scale by 2**e */
+      PUT_BITS_DP64(((long long)e + EXPBIAS_DP64) << EXPSHIFTBITS_DP64, r);
+      z *= r;
+    }
+
+  return z;
+
+}
+#endif /* SQRT_AMD_INLINE */
+
+#if defined(USE_SQRTF_AMD_INLINE)
+
+static inline float sqrtf_amd_inline(float x)
+{
+  /*
+     Computes the square root of x.
+
+     The calculation is carried out in three steps.
+
+     Step 1. Reduction.
+     The input argument is scaled to the interval [1, 4) by
+     computing
+               x = 2^e * y, where y in [1,4).
+     Furthermore y is decomposed as y = c + t where
+               c = 1 + j/32, j = 0,1,..,96; and |t| <= 1/64.
+
+     Step 2. Approximation.
+     An approximation q = sqrt(1 + (t/c)) - 1  is obtained
+     from a basic series expansion using precomputed values
+     stored in rt_jby32_lead_table_float and rt_jby32_trail_table_float.
+
+     Step 3. Reconstruction.
+     The value of sqrt(x) is reconstructed via
+       sqrt(x) = 2^(e/2) * sqrt(y)
+               = 2^(e/2) * sqrt(c) * sqrt(y/c)
+               = 2^(e/2) * sqrt(c) * sqrt(1 + t/c)
+               = 2^(e/2) * [ sqrt(c) + sqrt(c)*q ]
+    */
+
+  unsigned int ux, ax, u;
+  float r1, r2, c, y, p, q, r, twop, z, rtc, rtc_lead, rtc_trail;
+  int e, denorm = 0, index;
+
+/* Arrays rt_jby32_lead_table_float and rt_jby32_trail_table_float contain
+   leading and trailing parts respectively of precomputed
+   values of sqrt(j/32), for j = 32, 33, ..., 128.
+   rt_jby32_lead_table_float contains the first 13 bits of precision,
+   and rt_jby32_trail_table_float contains a further 24 bits precision. */
+
+static const float rt_jby32_lead_table_float[97] = {
+    1.00000000000000000000e+00F,   /* 0x3f800000 */
+    1.01538085937500000000e+00F,   /* 0x3f81f800 */
+    1.03076171875000000000e+00F,   /* 0x3f83f000 */
+    1.04565429687500000000e+00F,   /* 0x3f85d800 */
+    1.06054687500000000000e+00F,   /* 0x3f87c000 */
+    1.07519531250000000000e+00F,   /* 0x3f89a000 */
+    1.08959960937500000000e+00F,   /* 0x3f8b7800 */
+    1.10375976562500000000e+00F,   /* 0x3f8d4800 */
+    1.11791992187500000000e+00F,   /* 0x3f8f1800 */
+    1.13183593750000000000e+00F,   /* 0x3f90e000 */
+    1.14550781250000000000e+00F,   /* 0x3f92a000 */
+    1.15917968750000000000e+00F,   /* 0x3f946000 */
+    1.17236328125000000000e+00F,   /* 0x3f961000 */
+    1.18579101562500000000e+00F,   /* 0x3f97c800 */
+    1.19873046875000000000e+00F,   /* 0x3f997000 */
+    1.21191406250000000000e+00F,   /* 0x3f9b2000 */
+    1.22460937500000000000e+00F,   /* 0x3f9cc000 */
+    1.23730468750000000000e+00F,   /* 0x3f9e6000 */
+    1.25000000000000000000e+00F,   /* 0x3fa00000 */
+    1.26220703125000000000e+00F,   /* 0x3fa19000 */
+    1.27465820312500000000e+00F,   /* 0x3fa32800 */
+    1.28686523437500000000e+00F,   /* 0x3fa4b800 */
+    1.29882812500000000000e+00F,   /* 0x3fa64000 */
+    1.31079101562500000000e+00F,   /* 0x3fa7c800 */
+    1.32275390625000000000e+00F,   /* 0x3fa95000 */
+    1.33447265625000000000e+00F,   /* 0x3faad000 */
+    1.34619140625000000000e+00F,   /* 0x3fac5000 */
+    1.35766601562500000000e+00F,   /* 0x3fadc800 */
+    1.36914062500000000000e+00F,   /* 0x3faf4000 */
+    1.38061523437500000000e+00F,   /* 0x3fb0b800 */
+    1.39184570312500000000e+00F,   /* 0x3fb22800 */
+    1.40307617187500000000e+00F,   /* 0x3fb39800 */
+    1.41406250000000000000e+00F,   /* 0x3fb50000 */
+    1.42504882812500000000e+00F,   /* 0x3fb66800 */
+    1.43603515625000000000e+00F,   /* 0x3fb7d000 */
+    1.44677734375000000000e+00F,   /* 0x3fb93000 */
+    1.45751953125000000000e+00F,   /* 0x3fba9000 */
+    1.46826171875000000000e+00F,   /* 0x3fbbf000 */
+    1.47900390625000000000e+00F,   /* 0x3fbd5000 */
+    1.48950195312500000000e+00F,   /* 0x3fbea800 */
+    1.50000000000000000000e+00F,   /* 0x3fc00000 */
+    1.51025390625000000000e+00F,   /* 0x3fc15000 */
+    1.52050781250000000000e+00F,   /* 0x3fc2a000 */
+    1.53076171875000000000e+00F,   /* 0x3fc3f000 */
+    1.54101562500000000000e+00F,   /* 0x3fc54000 */
+    1.55102539062500000000e+00F,   /* 0x3fc68800 */
+    1.56103515625000000000e+00F,   /* 0x3fc7d000 */
+    1.57104492187500000000e+00F,   /* 0x3fc91800 */
+    1.58105468750000000000e+00F,   /* 0x3fca6000 */
+    1.59082031250000000000e+00F,   /* 0x3fcba000 */
+    1.60058593750000000000e+00F,   /* 0x3fcce000 */
+    1.61035156250000000000e+00F,   /* 0x3fce2000 */
+    1.62011718750000000000e+00F,   /* 0x3fcf6000 */
+    1.62963867187500000000e+00F,   /* 0x3fd09800 */
+    1.63916015625000000000e+00F,   /* 0x3fd1d000 */
+    1.64868164062500000000e+00F,   /* 0x3fd30800 */
+    1.65820312500000000000e+00F,   /* 0x3fd44000 */
+    1.66748046875000000000e+00F,   /* 0x3fd57000 */
+    1.67700195312500000000e+00F,   /* 0x3fd6a800 */
+    1.68627929687500000000e+00F,   /* 0x3fd7d800 */
+    1.69555664062500000000e+00F,   /* 0x3fd90800 */
+    1.70458984375000000000e+00F,   /* 0x3fda3000 */
+    1.71386718750000000000e+00F,   /* 0x3fdb6000 */
+    1.72290039062500000000e+00F,   /* 0x3fdc8800 */
+    1.73193359375000000000e+00F,   /* 0x3fddb000 */
+    1.74096679687500000000e+00F,   /* 0x3fded800 */
+    1.75000000000000000000e+00F,   /* 0x3fe00000 */
+    1.75878906250000000000e+00F,   /* 0x3fe12000 */
+    1.76757812500000000000e+00F,   /* 0x3fe24000 */
+    1.77636718750000000000e+00F,   /* 0x3fe36000 */
+    1.78515625000000000000e+00F,   /* 0x3fe48000 */
+    1.79394531250000000000e+00F,   /* 0x3fe5a000 */
+    1.80273437500000000000e+00F,   /* 0x3fe6c000 */
+    1.81127929687500000000e+00F,   /* 0x3fe7d800 */
+    1.81982421875000000000e+00F,   /* 0x3fe8f000 */
+    1.82836914062500000000e+00F,   /* 0x3fea0800 */
+    1.83691406250000000000e+00F,   /* 0x3feb2000 */
+    1.84545898437500000000e+00F,   /* 0x3fec3800 */
+    1.85400390625000000000e+00F,   /* 0x3fed5000 */
+    1.86230468750000000000e+00F,   /* 0x3fee6000 */
+    1.87060546875000000000e+00F,   /* 0x3fef7000 */
+    1.87915039062500000000e+00F,   /* 0x3ff08800 */
+    1.88745117187500000000e+00F,   /* 0x3ff19800 */
+    1.89550781250000000000e+00F,   /* 0x3ff2a000 */
+    1.90380859375000000000e+00F,   /* 0x3ff3b000 */
+    1.91210937500000000000e+00F,   /* 0x3ff4c000 */
+    1.92016601562500000000e+00F,   /* 0x3ff5c800 */
+    1.92822265625000000000e+00F,   /* 0x3ff6d000 */
+    1.93627929687500000000e+00F,   /* 0x3ff7d800 */
+    1.94433593750000000000e+00F,   /* 0x3ff8e000 */
+    1.95239257812500000000e+00F,   /* 0x3ff9e800 */
+    1.96044921875000000000e+00F,   /* 0x3ffaf000 */
+    1.96826171875000000000e+00F,   /* 0x3ffbf000 */
+    1.97631835937500000000e+00F,   /* 0x3ffcf800 */
+    1.98413085937500000000e+00F,   /* 0x3ffdf800 */
+    1.99194335937500000000e+00F,   /* 0x3ffef800 */
+    2.00000000000000000000e+00F};  /* 0x40000000 */
+
+static const float rt_jby32_trail_table_float[97] = {
+    0.00000000000000000000e+00F,   /* 0x00000000 */
+    1.23941208585165441036e-04F,   /* 0x3901f637 */
+    1.46876545841223560274e-05F,   /* 0x37766aff */
+    1.70736297150142490864e-04F,   /* 0x393307ad */
+    1.13296780909877270460e-04F,   /* 0x38ed99bf */
+    9.53458802541717886925e-05F,   /* 0x38c7f46e */
+    1.25126505736261606216e-04F,   /* 0x39033464 */
+    2.10342666832730174065e-04F,   /* 0x395c8f6e */
+    1.14066875539720058441e-04F,   /* 0x38ef3730 */
+    8.72047676239162683487e-05F,   /* 0x38b6e1b4 */
+    1.36111237225122749805e-04F,   /* 0x390eb915 */
+    2.26244374061934649944e-05F,   /* 0x37bdc99c */
+    2.40658700931817293167e-04F,   /* 0x397c5954 */
+    6.31069415248930454254e-05F,   /* 0x38845848 */
+    2.27412077947519719601e-04F,   /* 0x396e7577 */
+    5.90185391047270968556e-06F,   /* 0x36c6088a */
+    1.35496389702893793583e-04F,   /* 0x390e1409 */
+    1.32179571664892137051e-04F,   /* 0x390a99af */
+    0.00000000000000000000e+00F,   /* 0x00000000 */
+    2.31086043640971183777e-04F,   /* 0x39724fb0 */
+    9.66752704698592424393e-05F,   /* 0x38cabe24 */
+    8.85332483449019491673e-05F,   /* 0x38b9aaed */
+    2.09980673389509320259e-04F,   /* 0x395c2e42 */
+    2.20044588786549866199e-04F,   /* 0x3966bbc5 */
+    1.21749282698146998882e-04F,   /* 0x38ff53a6 */
+    1.62125259521417319775e-04F,   /* 0x392a002b */
+    9.97955357888713479042e-05F,   /* 0x38d14952 */
+    1.81545779923908412457e-04F,   /* 0x393e5d53 */
+    1.65768768056295812130e-04F,   /* 0x392dd237 */
+    5.48927710042335093021e-05F,   /* 0x38663caa */
+    9.53875860432162880898e-05F,   /* 0x38c80ad2 */
+    4.53481625299900770187e-05F,   /* 0x383e3438 */
+    1.51062369695864617825e-04F,   /* 0x391e667f */
+    1.70453247847035527229e-04F,   /* 0x3932bbb2 */
+    1.05505387182347476482e-04F,   /* 0x38dd42c6 */
+    2.02269104192964732647e-04F,   /* 0x39541833 */
+    2.18442466575652360916e-04F,   /* 0x39650db4 */
+    1.55796806211583316326e-04F,   /* 0x39235d63 */
+    1.60395247803535312414e-05F,   /* 0x37868c9e */
+    4.49578510597348213196e-05F,   /* 0x383c9120 */
+    0.00000000000000000000e+00F,   /* 0x00000000 */
+    1.26840444863773882389e-04F,   /* 0x39050079 */
+    1.82820076588541269302e-04F,   /* 0x393fb364 */
+    1.69370483490638434887e-04F,   /* 0x3931990b */
+    8.78757418831810355186e-05F,   /* 0x38b849ee */
+    1.83815121999941766262e-04F,   /* 0x3940be7f */
+    2.14343352126888930798e-04F,   /* 0x3960c15b */
+    1.80714370799250900745e-04F,   /* 0x393d7e25 */
+    8.41425862745381891727e-05F,   /* 0x38b075b5 */
+    1.69945167726837098598e-04F,   /* 0x3932334f */
+    1.95121858268976211548e-04F,   /* 0x394c99a0 */
+    1.60778334247879683971e-04F,   /* 0x3928969b */
+    6.79871009197086095810e-05F,   /* 0x388e944c */
+    1.61929419846273958683e-04F,   /* 0x3929cb99 */
+    1.99474830878898501396e-04F,   /* 0x39512a1e */
+    1.81604162207804620266e-04F,   /* 0x393e6cff */
+    1.09270178654696792364e-04F,   /* 0x38e527fb */
+    2.27539261686615645885e-04F,   /* 0x396e979b */
+    4.90300008095800876617e-05F,   /* 0x384da590 */
+    6.28985289949923753738e-05F,   /* 0x3883e864 */
+    2.58551553997676819563e-05F,   /* 0x37d8e386 */
+    1.82868374395184218884e-04F,   /* 0x393fc05b */
+    4.64625991298817098141e-05F,   /* 0x3842e0d6 */
+    1.05703387816902250051e-04F,   /* 0x38ddad13 */
+    1.17213814519345760345e-04F,   /* 0x38f5d0b0 */
+    8.17377731436863541603e-05F,   /* 0x38ab6aa2 */
+    0.00000000000000000000e+00F,   /* 0x00000000 */
+    1.16847433673683553934e-04F,   /* 0x38f50bfd */
+    1.88827965757809579372e-04F,   /* 0x3946001f */
+    2.16612941585481166840e-04F,   /* 0x39632298 */
+    2.00857131858356297016e-04F,   /* 0x39529d2d */
+    1.42199307447299361229e-04F,   /* 0x39151b56 */
+    4.12627305195201188326e-05F,   /* 0x382d1185 */
+    1.42796401632949709892e-04F,   /* 0x3915bb9e */
+    2.03253570361994206905e-04F,   /* 0x39552077 */
+    2.23214170546270906925e-04F,   /* 0x396a0e99 */
+    2.03244591830298304558e-04F,   /* 0x39551e0e */
+    1.43898156238719820976e-04F,   /* 0x3916e35e */
+    4.57155256299301981926e-05F,   /* 0x383fbeac */
+    1.53365719597786664963e-04F,   /* 0x3920d0cc */
+    2.23224633373320102692e-04F,   /* 0x396a1168 */
+    1.16566716314991936088e-05F,   /* 0x37439106 */
+    7.43694272387074306607e-06F,   /* 0x36f98ada */
+    2.11048507480882108212e-04F,   /* 0x395d4ce7 */
+    1.34682719362899661064e-04F,   /* 0x390d399e */
+    2.29425968427676707506e-05F,   /* 0x37c074da */
+    1.20421340398024767637e-04F,   /* 0x38fc8ab7 */
+    1.83421318070031702518e-04F,   /* 0x394054c9 */
+    2.12376224226318299770e-04F,   /* 0x395eb14f */
+    2.07710763788782060146e-04F,   /* 0x3959ccef */
+    1.69840845046564936638e-04F,   /* 0x3932174e */
+    9.91739216260612010956e-05F,   /* 0x38cffb98 */
+    2.40249748458154499531e-04F,   /* 0x397beb8d */
+    1.05178231024183332920e-04F,   /* 0x38dc9322 */
+    1.82623916771262884140e-04F,   /* 0x393f7ebc */
+    2.28821940254420042038e-04F,   /* 0x396fefec */
+    0.00000000000000000000e+00F};  /* 0x00000000 */
+
+
+/* Handle special arguments first */
+
+  GET_BITS_SP32(x, ux);
+  ax = ux & (~SIGNBIT_SP32);
+
+  if(ax >= 0x7f800000)
+    {
+      /* x is either NaN or infinity */
+      if (ux & MANTBITS_SP32)
+        /* x is NaN */
+        return x + x; /* Raise invalid if it is a signalling NaN */
+      else if (ux & SIGNBIT_SP32)
+        return nanf_with_flags(AMD_F_INVALID);
+      else
+        /* x is positive infinity */
+        return x;
+    }
+  else if (ux & SIGNBIT_SP32)
+    {
+      /* x is negative. */
+      if (x == 0.0F)
+        /* Handle negative zero first */
+        return x;
+      else
+        return nanf_with_flags(AMD_F_INVALID);
+    }
+  else if (ux <= 0x007fffff)
+    {
+      /* x is denormalised or zero */
+      if (ux == 0)
+        /* x is zero */
+        return x;
+      else
+        {
+          /* x is denormalised; scale it up */
+          /* Normalize x by increasing the exponent by 26
+             and subtracting a correction to account for the implicit
+             bit. This replaces a slow denormalized
+             multiplication by a fast normal subtraction. */
+          static const float corr = 7.888609052210118054e-31F; /* 0x0d800000 */
+          denorm = 1;
+          GET_BITS_SP32(x, ux);
+          PUT_BITS_SP32(ux | 0x0d800000, x);
+          x -= corr;
+          GET_BITS_SP32(x, ux);
+        }
+    }
+
+  /* Main algorithm */
+
+  /*
+     Find y and e such that x = 2^e * y, where y in [1,4).
+     This is done using an in-lined variant of splitFloat,
+     which also ensures that e is even.
+   */
+  y = x;
+  ux &= EXPBITS_SP32;
+  ux >>= EXPSHIFTBITS_SP32;
+  if (ux & 1)
+    {
+      GET_BITS_SP32(y, u);
+      u &= (SIGNBIT_SP32 | MANTBITS_SP32);
+      u |= ONEEXPBITS_SP32;
+      PUT_BITS_SP32(u, y);
+      e = ux - EXPBIAS_SP32;
+    }
+  else
+    {
+      GET_BITS_SP32(y, u);
+      u &= (SIGNBIT_SP32 | MANTBITS_SP32);
+      u |= TWOEXPBITS_SP32;
+      PUT_BITS_SP32(u, y);
+      e = ux - EXPBIAS_SP32 - 1;
+    }
+
+  /* Find the index of the sub-interval of [1,4) in which y lies. */
+
+  index = (int)(32.0F*y+0.5);
+
+  /* Look up the table values and compute c and r = c/t */
+
+  rtc_lead = rt_jby32_lead_table_float[index-32];
+  rtc_trail = rt_jby32_trail_table_float[index-32];
+  c = 0.03125F*index;
+  r = (y - c)/c;
+
+  /*
+  Find q = sqrt(1+r) - 1.
+  From one step of Newton on (q+1)^2 = 1+r
+  */
+
+  p = r*0.5F - r*r*(0.1250079870F - r*(0.6250522999e-01F));
+  twop = p + p;
+  q = p - (p*p + (twop - r))/(twop + 2.0);
+
+  /* Reconstruction */
+
+  rtc = rtc_lead + rtc_trail;
+  e >>= 1; /* e = e/2 */
+  z = rtc_lead + (rtc*q+rtc_trail);
+
+  if (denorm)
+    {
+      /* Scale by 2**(e-13) */
+      PUT_BITS_SP32(((e - 13) + EXPBIAS_SP32) << EXPSHIFTBITS_SP32, r);
+      z *= r;
+    }
+  else
+    {
+      /* Scale by 2**e */
+      PUT_BITS_SP32((e + EXPBIAS_SP32) << EXPSHIFTBITS_SP32, r);
+      z *= r;
+    }
+
+  return z;
+
+}
+#endif /* SQRTF_AMD_INLINE */
+
+#ifdef USE_LOG_KERNEL_AMD
+static inline void log_kernel_amd64(double x, unsigned long long ux, int *xexp, double *r1, double *r2)
+{
+
+  int expadjust;
+  double r, z1, z2, correction, f, f1, f2, q, u, v, poly;
+  int index;
+
+  /*
+    Computes natural log(x). Algorithm based on:
+    Ping-Tak Peter Tang
+    "Table-driven implementation of the logarithm function in IEEE
+    floating-point arithmetic"
+    ACM Transactions on Mathematical Software (TOMS)
+    Volume 16, Issue 4 (December 1990)
+  */
+
+/* Arrays ln_lead_table and ln_tail_table contain
+   leading and trailing parts respectively of precomputed
+   values of natural log(1+i/64), for i = 0, 1, ..., 64.
+   ln_lead_table contains the first 24 bits of precision,
+   and ln_tail_table contains a further 53 bits precision. */
+
+  static const double ln_lead_table[65] = {
+    0.00000000000000000000e+00,   /* 0x0000000000000000 */
+    1.55041813850402832031e-02,   /* 0x3f8fc0a800000000 */
+    3.07716131210327148438e-02,   /* 0x3f9f829800000000 */
+    4.58095073699951171875e-02,   /* 0x3fa7745800000000 */
+    6.06245994567871093750e-02,   /* 0x3faf0a3000000000 */
+    7.52233862876892089844e-02,   /* 0x3fb341d700000000 */
+    8.96121263504028320312e-02,   /* 0x3fb6f0d200000000 */
+    1.03796780109405517578e-01,   /* 0x3fba926d00000000 */
+    1.17783010005950927734e-01,   /* 0x3fbe270700000000 */
+    1.31576299667358398438e-01,   /* 0x3fc0d77e00000000 */
+    1.45181953907012939453e-01,   /* 0x3fc2955280000000 */
+    1.58604979515075683594e-01,   /* 0x3fc44d2b00000000 */
+    1.71850204467773437500e-01,   /* 0x3fc5ff3000000000 */
+    1.84922337532043457031e-01,   /* 0x3fc7ab8900000000 */
+    1.97825729846954345703e-01,   /* 0x3fc9525a80000000 */
+    2.10564732551574707031e-01,   /* 0x3fcaf3c900000000 */
+    2.23143517971038818359e-01,   /* 0x3fcc8ff780000000 */
+    2.35566020011901855469e-01,   /* 0x3fce270700000000 */
+    2.47836112976074218750e-01,   /* 0x3fcfb91800000000 */
+    2.59957492351531982422e-01,   /* 0x3fd0a324c0000000 */
+    2.71933674812316894531e-01,   /* 0x3fd1675c80000000 */
+    2.83768117427825927734e-01,   /* 0x3fd22941c0000000 */
+    2.95464158058166503906e-01,   /* 0x3fd2e8e280000000 */
+    3.07025015354156494141e-01,   /* 0x3fd3a64c40000000 */
+    3.18453729152679443359e-01,   /* 0x3fd4618bc0000000 */
+    3.29753279685974121094e-01,   /* 0x3fd51aad80000000 */
+    3.40926527976989746094e-01,   /* 0x3fd5d1bd80000000 */
+    3.51976394653320312500e-01,   /* 0x3fd686c800000000 */
+    3.62905442714691162109e-01,   /* 0x3fd739d7c0000000 */
+    3.73716354370117187500e-01,   /* 0x3fd7eaf800000000 */
+    3.84411692619323730469e-01,   /* 0x3fd89a3380000000 */
+    3.94993782043457031250e-01,   /* 0x3fd9479400000000 */
+    4.05465066432952880859e-01,   /* 0x3fd9f323c0000000 */
+    4.15827870368957519531e-01,   /* 0x3fda9cec80000000 */
+    4.26084339618682861328e-01,   /* 0x3fdb44f740000000 */
+    4.36236739158630371094e-01,   /* 0x3fdbeb4d80000000 */
+    4.46287095546722412109e-01,   /* 0x3fdc8ff7c0000000 */
+    4.56237375736236572266e-01,   /* 0x3fdd32fe40000000 */
+    4.66089725494384765625e-01,   /* 0x3fddd46a00000000 */
+    4.75845873355865478516e-01,   /* 0x3fde744240000000 */
+    4.85507786273956298828e-01,   /* 0x3fdf128f40000000 */
+    4.95077252388000488281e-01,   /* 0x3fdfaf5880000000 */
+    5.04556000232696533203e-01,   /* 0x3fe02552a0000000 */
+    5.13945698738098144531e-01,   /* 0x3fe0723e40000000 */
+    5.23248136043548583984e-01,   /* 0x3fe0be72e0000000 */
+    5.32464742660522460938e-01,   /* 0x3fe109f380000000 */
+    5.41597247123718261719e-01,   /* 0x3fe154c3c0000000 */
+    5.50647079944610595703e-01,   /* 0x3fe19ee6a0000000 */
+    5.59615731239318847656e-01,   /* 0x3fe1e85f40000000 */
+    5.68504691123962402344e-01,   /* 0x3fe23130c0000000 */
+    5.77315330505371093750e-01,   /* 0x3fe2795e00000000 */
+    5.86049020290374755859e-01,   /* 0x3fe2c0e9e0000000 */
+    5.94707071781158447266e-01,   /* 0x3fe307d720000000 */
+    6.03290796279907226562e-01,   /* 0x3fe34e2880000000 */
+    6.11801505088806152344e-01,   /* 0x3fe393e0c0000000 */
+    6.20240390300750732422e-01,   /* 0x3fe3d90260000000 */
+    6.28608644008636474609e-01,   /* 0x3fe41d8fe0000000 */
+    6.36907458305358886719e-01,   /* 0x3fe4618bc0000000 */
+    6.45137906074523925781e-01,   /* 0x3fe4a4f840000000 */
+    6.53301239013671875000e-01,   /* 0x3fe4e7d800000000 */
+    6.61398470401763916016e-01,   /* 0x3fe52a2d20000000 */
+    6.69430613517761230469e-01,   /* 0x3fe56bf9c0000000 */
+    6.77398800849914550781e-01,   /* 0x3fe5ad4040000000 */
+    6.85303986072540283203e-01,   /* 0x3fe5ee02a0000000 */
+    6.93147122859954833984e-01};  /* 0x3fe62e42e0000000 */
+
+  static const double ln_tail_table[65] = {
+    0.00000000000000000000e+00,   /* 0x0000000000000000 */
+    5.15092497094772879206e-09,   /* 0x3e361f807c79f3db */
+    4.55457209735272790188e-08,   /* 0x3e6873c1980267c8 */
+    2.86612990859791781788e-08,   /* 0x3e5ec65b9f88c69e */
+    2.23596477332056055352e-08,   /* 0x3e58022c54cc2f99 */
+    3.49498983167142274770e-08,   /* 0x3e62c37a3a125330 */
+    3.23392843005887000414e-08,   /* 0x3e615cad69737c93 */
+    1.35722380472479366661e-08,   /* 0x3e4d256ab1b285e9 */
+    2.56504325268044191098e-08,   /* 0x3e5b8abcb97a7aa2 */
+    5.81213608741512136843e-08,   /* 0x3e6f34239659a5dc */
+    5.59374849578288093334e-08,   /* 0x3e6e07fd48d30177 */
+    5.06615629004996189970e-08,   /* 0x3e6b32df4799f4f6 */
+    5.24588857848400955725e-08,   /* 0x3e6c29e4f4f21cf8 */
+    9.61968535632653505972e-10,   /* 0x3e1086c848df1b59 */
+    1.34829655346594463137e-08,   /* 0x3e4cf456b4764130 */
+    3.65557749306383026498e-08,   /* 0x3e63a02ffcb63398 */
+    3.33431709374069198903e-08,   /* 0x3e61e6a6886b0976 */
+    5.13008650536088382197e-08,   /* 0x3e6b8abcb97a7aa2 */
+    5.09285070380306053751e-08,   /* 0x3e6b578f8aa35552 */
+    3.20853940845502057341e-08,   /* 0x3e6139c871afb9fc */
+    4.06713248643004200446e-08,   /* 0x3e65d5d30701ce64 */
+    5.57028186706125221168e-08,   /* 0x3e6de7bcb2d12142 */
+    5.48356693724804282546e-08,   /* 0x3e6d708e984e1664 */
+    1.99407553679345001938e-08,   /* 0x3e556945e9c72f36 */
+    1.96585517245087232086e-09,   /* 0x3e20e2f613e85bda */
+    6.68649386072067321503e-09,   /* 0x3e3cb7e0b42724f6 */
+    5.89936034642113390002e-08,   /* 0x3e6fac04e52846c7 */
+    2.85038578721554472484e-08,   /* 0x3e5e9b14aec442be */
+    5.09746772910284482606e-08,   /* 0x3e6b5de8034e7126 */
+    5.54234668933210171467e-08,   /* 0x3e6dc157e1b259d3 */
+    6.29100830926604004874e-09,   /* 0x3e3b05096ad69c62 */
+    2.61974119468563937716e-08,   /* 0x3e5c2116faba4cdd */
+    4.16752115011186398935e-08,   /* 0x3e665fcc25f95b47 */
+    2.47747534460820790327e-08,   /* 0x3e5a9a08498d4850 */
+    5.56922172017964209793e-08,   /* 0x3e6de647b1465f77 */
+    2.76162876992552906035e-08,   /* 0x3e5da71b7bf7861d */
+    7.08169709942321478061e-09,   /* 0x3e3e6a6886b09760 */
+    5.77453510221151779025e-08,   /* 0x3e6f0075eab0ef64 */
+    4.43021445893361960146e-09,   /* 0x3e33071282fb989b */
+    3.15140984357495864573e-08,   /* 0x3e60eb43c3f1bed2 */
+    2.95077445089736670973e-08,   /* 0x3e5faf06ecb35c84 */
+    1.44098510263167149349e-08,   /* 0x3e4ef1e63db35f68 */
+    1.05196987538551827693e-08,   /* 0x3e469743fb1a71a5 */
+    5.23641361722697546261e-08,   /* 0x3e6c1cdf404e5796 */
+    7.72099925253243069458e-09,   /* 0x3e4094aa0ada625e */
+    5.62089493829364197156e-08,   /* 0x3e6e2d4c96fde3ec */
+    3.53090261098577946927e-08,   /* 0x3e62f4d5e9a98f34 */
+    3.80080516835568242269e-08,   /* 0x3e6467c96ecc5cbe */
+    5.66961038386146408282e-08,   /* 0x3e6e7040d03dec5a */
+    4.42287063097349852717e-08,   /* 0x3e67bebf4282de36 */
+    3.45294525105681104660e-08,   /* 0x3e6289b11aeb783f */
+    2.47132034530447431509e-08,   /* 0x3e5a891d1772f538 */
+    3.59655343422487209774e-08,   /* 0x3e634f10be1fb591 */
+    5.51581770357780862071e-08,   /* 0x3e6d9ce1d316eb93 */
+    3.60171867511861372793e-08,   /* 0x3e63562a19a9c442 */
+    1.94511067964296180547e-08,   /* 0x3e54e2adf548084c */
+    1.54137376631349347838e-08,   /* 0x3e508ce55cc8c97a */
+    3.93171034490174464173e-09,   /* 0x3e30e2f613e85bda */
+    5.52990607758839766440e-08,   /* 0x3e6db03ebb0227bf */
+    3.29990737637586136511e-08,   /* 0x3e61b75bb09cb098 */
+    1.18436010922446096216e-08,   /* 0x3e496f16abb9df22 */
+    4.04248680368301346709e-08,   /* 0x3e65b3f399411c62 */
+    2.27418915900284316293e-08,   /* 0x3e586b3e59f65355 */
+    1.70263791333409206020e-08,   /* 0x3e52482ceae1ac12 */
+    5.76999904754328540596e-08};  /* 0x3e6efa39ef35793c */
+
+  /* Approximating polynomial coefficients for x near 1.0 */
+  static const double
+    ca_1 = 8.33333333333317923934e-02,  /* 0x3fb55555555554e6 */
+    ca_2 = 1.25000000037717509602e-02,  /* 0x3f89999999bac6d4 */
+    ca_3 = 2.23213998791944806202e-03,  /* 0x3f62492307f1519f */
+    ca_4 = 4.34887777707614552256e-04;  /* 0x3f3c8034c85dfff0 */
+
+  /* Approximating polynomial coefficients for other x */
+  static const double
+    cb_1 = 8.33333333333333593622e-02,  /* 0x3fb5555555555557 */
+    cb_2 = 1.24999999978138668903e-02,  /* 0x3f89999999865ede */
+    cb_3 = 2.23219810758559851206e-03;  /* 0x3f6249423bd94741 */
+
+  static const unsigned long long
+    log_thresh1 = 0x3fee0faa00000000,
+    log_thresh2 = 0x3ff1082c00000000;
+
+  /* log_thresh1 = 9.39412117004394531250e-1 = 0x3fee0faa00000000
+     log_thresh2 = 1.06449508666992187500 = 0x3ff1082c00000000 */
+  if (ux >= log_thresh1 && ux <= log_thresh2)
+    {
+      /* Arguments close to 1.0 are handled separately to maintain
+         accuracy.
+
+         The approximation in this region exploits the identity
+             log( 1 + r ) = log( 1 + u/2 )  /  log( 1 - u/2 ), where
+             u  = 2r / (2+r).
+         Note that the right hand side has an odd Taylor series expansion
+         which converges much faster than the Taylor series expansion of
+         log( 1 + r ) in r. Thus, we approximate log( 1 + r ) by
+             u + A1 * u^3 + A2 * u^5 + ... + An * u^(2n+1).
+
+         One subtlety is that since u cannot be calculated from
+         r exactly, the rounding error in the first u should be
+         avoided if possible. To accomplish this, we observe that
+                       u  =  r  -  r*r/(2+r).
+         Since x (=1+r) is the input argument, and thus presumed exact,
+         the formula above approximates u accurately because
+                       u  =  r  -  correction,
+         and the magnitude of "correction" (of the order of r*r)
+         is small.
+         With these observations, we will approximate log( 1 + r ) by
+            r + (  (A1*u^3 + ... + An*u^(2n+1)) - correction ).
+
+         We approximate log(1+r) by an odd polynomial in u, where
+                  u = 2r/(2+r) = r - r*r/(2+r).
+      */
+      r = x - 1.0;
+      u = r / (2.0 + r);
+      correction = r * u;
+      u = u + u;
+      v = u * u;
+      z1 = r;
+      z2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+      *r1 = z1;
+      *r2 = z2;
+      *xexp = 0;
+    }
+  else
+    {
+      /*
+        First, we decompose the argument x to the form
+        x  =  2**M  *  (F1  +  F2),
+        where  1 <= F1+F2 < 2, M has the value of an integer,
+        F1 = 1 + j/64, j ranges from 0 to 64, and |F2| <= 1/128.
+
+        Second, we approximate log( 1 + F2/F1 ) by an odd polynomial
+        in U, where U  =  2 F2 / (2 F2 + F1).
+        Note that log( 1 + F2/F1 ) = log( 1 + U/2 ) - log( 1 - U/2 ).
+        The core approximation calculates
+        Poly = [log( 1 + U/2 ) - log( 1 - U/2 )]/U   -   1.
+        Note that  log(1 + U/2) - log(1 - U/2) = 2 arctanh ( U/2 ),
+        thus, Poly =  2 arctanh( U/2 ) / U  -  1.
+
+        It is not hard to see that
+          log(x) = M*log(2) + log(F1) + log( 1 + F2/F1 ).
+        Hence, we return Z1 = log(F1), and  Z2 = log( 1 + F2/F1).
+        The values of log(F1) are calculated beforehand and stored
+        in the program.
+      */
+
+      f = x;
+      if (ux < IMPBIT_DP64)
+        {
+          /* The input argument x is denormalized */
+          /* Normalize f by increasing the exponent by 60
+             and subtracting a correction to account for the implicit
+             bit. This replaces a slow denormalized
+             multiplication by a fast normal subtraction. */
+          static const double corr = 2.5653355008114851558350183e-290; /* 0x03d0000000000000 */
+          GET_BITS_DP64(f, ux);
+          ux |= 0x03d0000000000000;
+          PUT_BITS_DP64(ux, f);
+          f -= corr;
+          GET_BITS_DP64(f, ux);
+          expadjust = 60;
+        }
+      else
+        expadjust = 0;
+
+      /* Store the exponent of x in xexp and put
+         f into the range [0.5,1) */
+      *xexp = (int)((ux & EXPBITS_DP64) >> EXPSHIFTBITS_DP64) - EXPBIAS_DP64 - expadjust;
+      PUT_BITS_DP64((ux & MANTBITS_DP64) | HALFEXPBITS_DP64, f);
+
+      /* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+
+      /* Set index to be the nearest integer to 128*f */
+      r = 128.0 * f;
+      index = (int)(r + 0.5);
+
+      z1 = ln_lead_table[index-64];
+      q = ln_tail_table[index-64];
+      f1 = index * 0.0078125; /* 0.0078125 = 1/128 */
+      f2 = f - f1;
+      /* At this point, x = 2**xexp * ( f1  +  f2 ) where
+         f1 = j/128, j = 64, 65, ..., 128 and |f2| <= 1/256. */
+
+      /* Calculate u = 2 f2 / ( 2 f1 + f2 ) = f2 / ( f1 + 0.5*f2 ) */
+      /* u = f2 / (f1 + 0.5 * f2); */
+      u = f2 / (f1 + 0.5 * f2);
+
+      /* Here, |u| <= 2(exp(1/16)-1) / (exp(1/16)+1).
+         The core approximation calculates
+         poly = [log(1 + u/2) - log(1 - u/2)]/u  -  1  */
+      v = u * u;
+      poly = (v * (cb_1 + v * (cb_2 + v * cb_3)));
+      z2 = q + (u + u * poly);
+      *r1 = z1;
+      *r2 = z2;
+    }
+  return;
+}
+#endif /* USE_LOG_KERNEL_AMD */
+
+#if defined(USE_REMAINDER_PIBY2F_INLINE)
+/* Define this to get debugging print statements activated */
+#define DEBUGGING_PRINT
+#undef DEBUGGING_PRINT
+
+
+#ifdef DEBUGGING_PRINT
+#include <stdio.h>
+char *d2b(long long d, int bitsper, int point)
+{
+  static char buff[200];
+  int i, j;
+  j = bitsper;
+  if (point >= 0 && point <= bitsper)
+    j++;
+  buff[j] = '\0';
+  for (i = bitsper - 1; i >= 0; i--)
+    {
+      j--;
+      if (d % 2 == 1)
+        buff[j] = '1';
+      else
+        buff[j] = '0';
+      if (i == point)
+        {
+          j--;
+          buff[j] = '.';
+        }
+      d /= 2;
+    }
+  return buff;
+}
+#endif
+
+/* Given positive argument x, reduce it to the range [-pi/4,pi/4] using
+   extra precision, and return the result in r.
+   Return value "region" tells how many lots of pi/2 were subtracted
+   from x to put it in the range [-pi/4,pi/4], mod 4. */
+static inline void __remainder_piby2f_inline(unsigned long long ux, double *r, int *region)
+{
+
+      /* This method simulates multi-precision floating-point
+         arithmetic and is accurate for all 1 <= x < infinity */
+#define bitsper 36
+      unsigned long long res[10];
+      unsigned long long u, carry, mask, mant, nextbits;
+      int first, last, i, rexp, xexp, resexp, ltb, determ, bc;
+      double dx;
+      static const double
+        piby2 = 1.57079632679489655800e+00; /* 0x3ff921fb54442d18 */
+#ifdef WINDOWS
+      static unsigned long long pibits[] =
+      {
+        0LL,
+        5215LL, 13000023176LL, 11362338026LL, 67174558139LL,
+        34819822259LL, 10612056195LL, 67816420731LL, 57840157550LL,
+        19558516809LL, 50025467026LL, 25186875954LL, 18152700886LL
+      };
+#else
+      static unsigned long long pibits[] =
+      {
+        0L,
+        5215L, 13000023176L, 11362338026L, 67174558139L,
+        34819822259L, 10612056195L, 67816420731L, 57840157550L,
+        19558516809L, 50025467026L, 25186875954L, 18152700886L
+      };
+#endif
+
+#ifdef DEBUGGING_PRINT
+      printf("On entry, x = %25.20e = %s\n", x, double2hex(&x));
+#endif
+
+      xexp = (int)(((ux & EXPBITS_DP64) >> EXPSHIFTBITS_DP64) - EXPBIAS_DP64);
+      ux = ((ux & MANTBITS_DP64) | IMPBIT_DP64) >> 29;
+
+#ifdef DEBUGGING_PRINT
+      printf("ux = %s\n", d2b(ux, 64, -1));
+#endif
+
+      /* Now ux is the mantissa bit pattern of x as a long integer */
+      mask = 1;
+      mask = (mask << bitsper) - 1;
+
+      /* Set first and last to the positions of the first
+         and last chunks of 2/pi that we need */
+      first = xexp / bitsper;
+      resexp = xexp - first * bitsper;
+      /* 120 is the theoretical maximum number of bits (actually
+         115 for IEEE single precision) that we need to extract
+         from the middle of 2/pi to compute the reduced argument
+         accurately enough for our purposes */
+      last = first + 120 / bitsper;
+
+#ifdef DEBUGGING_PRINT
+      printf("first = %d, last = %d\n", first, last);
+#endif
+
+      /* Do a long multiplication of the bits of 2/pi by the
+         integer mantissa */
+      /* Unroll the loop. This is only correct because we know
+         that bitsper is fixed as 36. */
+      res[4] = 0;
+      u = pibits[last] * ux;
+      res[3] = u & mask;
+      carry = u >> bitsper;
+      u = pibits[last - 1] * ux + carry;
+      res[2] = u & mask;
+      carry = u >> bitsper;
+      u = pibits[last - 2] * ux + carry;
+      res[1] = u & mask;
+      carry = u >> bitsper;
+      u = pibits[first] * ux + carry;
+      res[0] = u & mask;
+
+#ifdef DEBUGGING_PRINT
+      printf("resexp = %d\n", resexp);
+      printf("Significant part of x * 2/pi with binary"
+             " point in correct place:\n");
+      for (i = 0; i <= last - first; i++)
+        {
+          if (i > 0 && i % 5 == 0)
+            printf("\n ");
+          if (i == 1)
+            printf("%s ", d2b(res[i], bitsper, resexp));
+          else
+            printf("%s ", d2b(res[i], bitsper, -1));
+        }
+      printf("\n");
+#endif
+
+      /* Reconstruct the result */
+      ltb = (int)((((res[0] << bitsper) | res[1])
+                   >> (bitsper - 1 - resexp)) & 7);
+
+      /* determ says whether the fractional part is >= 0.5 */
+      determ = ltb & 1;
+
+#ifdef DEBUGGING_PRINT
+      printf("ltb = %d (last two bits before binary point"
+             " and first bit after)\n", ltb);
+      printf("determ = %d (1 means need to negate because the fractional\n"
+             "            part of x * 2/pi is greater than 0.5)\n", determ);
+#endif
+
+      i = 1;
+      if (determ)
+        {
+          /* The mantissa is >= 0.5. We want to subtract it
+             from 1.0 by negating all the bits */
+          *region = ((ltb >> 1) + 1) & 3;
+          mant = 1;
+          mant = ~(res[1]) & ((mant << (bitsper - resexp)) - 1);
+          while (mant < 0x0000000000010000)
+            {
+              i++;
+              mant = (mant << bitsper) | (~(res[i]) & mask);
+            }
+          nextbits = (~(res[i+1]) & mask);
+        }
+      else
+        {
+          *region = (ltb >> 1);
+          mant = 1;
+          mant = res[1] & ((mant << (bitsper - resexp)) - 1);
+          while (mant < 0x0000000000010000)
+            {
+              i++;
+              mant = (mant << bitsper) | res[i];
+            }
+          nextbits = res[i+1];
+        }
+
+#ifdef DEBUGGING_PRINT
+      printf("First bits of mant = %s\n", d2b(mant, bitsper, -1));
+#endif
+
+      /* Normalize the mantissa. The shift value 6 here, determined by
+         trial and error, seems to give optimal speed. */
+      bc = 0;
+      while (mant < 0x0000400000000000LL)
+        {
+          bc += 6;
+          mant <<= 6;
+        }
+      while (mant < 0x0010000000000000LL)
+        {
+          bc++;
+          mant <<= 1;
+        }
+      mant |= nextbits >> (bitsper - bc);
+
+      rexp = 52 + resexp - bc - i * bitsper;
+
+#ifdef DEBUGGING_PRINT
+      printf("Normalised mantissa = 0x%016lx\n", mant);
+      printf("Exponent to be inserted on mantissa = rexp = %d\n", rexp);
+#endif
+
+      /* Put the result exponent rexp onto the mantissa pattern */
+      u = ((unsigned long long)rexp + EXPBIAS_DP64) << EXPSHIFTBITS_DP64;
+      ux = (mant & MANTBITS_DP64) | u;
+      if (determ)
+        /* If we negated the mantissa we negate x too */
+        ux |= SIGNBIT_DP64;
+      PUT_BITS_DP64(ux, dx);
+
+#ifdef DEBUGGING_PRINT
+      printf("(x*2/pi) = %25.20e = %s\n", dx, double2hex(&dx));
+#endif
+
+      /* x is a double precision version of the fractional part of
+         x * 2 / pi. Multiply x by pi/2 in double precision
+         to get the reduced argument r. */
+      *r = dx * piby2;
+
+#ifdef DEBUGGING_PRINT
+      printf(" r = frac(x*2/pi) * pi/2:\n");
+      printf(" r = %25.20e = %s\n", *r, double2hex(r));
+      printf("region = (number of pi/2 subtracted from x) mod 4 = %d\n",
+             *region);
+#endif
+}
+#endif /* USE_REMAINDER_PIBY2F_INLINE */
+
+#if defined(WINDOWS)
+#if defined(USE_HANDLE_ERROR) || defined(USE_HANDLE_ERRORF)
+#include <errno.h>
+#endif
+
+#if defined(USE_HANDLE_ERROR)
+/* Define the Microsoft specific error handling routines */
+static __declspec(noinline) double handle_error(const char *name,
+                                                unsigned long long value,
+                                                int type, int flags, int error,
+                                                double arg1, double arg2)
+{
+  double z;
+  struct _exception exception_data;
+  exception_data.type = type;
+  exception_data.name = (char*)name;
+  exception_data.arg1 = arg1;
+  exception_data.arg2 = arg2;
+  PUT_BITS_DP64(value, z);
+  exception_data.retval = z;
+  raise_fpsw_flags(flags);
+  if (!_matherr(&exception_data))
+    {
+      errno = error;
+    }
+  return exception_data.retval;
+}
+#endif /* USE_HANDLE_ERROR */
+
+#if defined(USE_HANDLE_ERRORF)
+static __declspec(noinline) float handle_errorf(const char *name,
+                                                unsigned int value,
+                                                int type, int flags, int error,
+                                                float arg1, float arg2)
+{
+  float z;
+  struct _exception exception_data;
+  exception_data.type = type;
+  exception_data.name = (char*)name;
+  exception_data.arg1 = (double)arg1;
+  exception_data.arg2 = (double)arg2;
+  PUT_BITS_SP32(value, z);
+  exception_data.retval = z;
+  raise_fpsw_flags(flags);
+  if (!_matherr(&exception_data))
+    {
+      errno = error;
+    }
+  return (float)exception_data.retval;
+}
+#endif /* USE_HANDLE_ERRORF */
+#endif /* WINDOWS */
+
+#endif /* LIBM_INLINES_AMD_H_INCLUDED */
diff --git a/inc/libm_special.h b/inc/libm_special.h
new file mode 100644
index 0000000..0833b7b
--- /dev/null
+++ b/inc/libm_special.h
@@ -0,0 +1,84 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifndef __LIBM_SPECIAL_H__
+#define __LIBM_SPECIAL_H__
+
+// exception status set
+#define MXCSR_ES_INEXACT       0x00000020
+#define MXCSR_ES_UNDERFLOW     0x00000010
+#define MXCSR_ES_OVERFLOW      0x00000008
+#define MXCSR_ES_DIVBYZERO     0x00000004
+#define MXCSR_ES_INVALID       0x00000001
+
+void __amd_handle_errorf(int type, int error, const char *name,
+                    float arg1, unsigned int arg1_is_snan,
+                    float arg2, unsigned int arg2_is_snan,
+                    float retval, unsigned int retval_is_snan);
+
+void __amd_handle_error(int type, int error, const char *name,
+                   double arg1,
+                   double arg2,
+                   double retval);
+
+/* Code from GRTE/v4 math.h */
+/* Types of exceptions in the `type' field.  */
+#ifndef DOMAIN
+struct exception
+  {
+    int type;
+    char *name;
+    double arg1;
+    double arg2;
+    double retval;
+  };
+
+extern int matherr (struct exception *__exc);
+
+# define X_TLOSS        1.41484755040568800000e+16
+
+/* Types of exceptions in the `type' field.  */
+# define DOMAIN         1
+# define SING           2
+# define OVERFLOW       3
+# define UNDERFLOW      4
+# define TLOSS          5
+# define PLOSS          6
+
+/* SVID mode specifies returning this large value instead of infinity.  */
+# define HUGE           3.40282347e+38F
+
+/* Use this define to enable a (dummy) definition of matherr().  */
+#define NEED_FAKE_MATHERR
+
+#else   /* !SVID */
+
+# ifdef __USE_XOPEN
+/* X/Open wants another strange constant.  */
+#  define MAXFLOAT      3.40282347e+38F
+# endif
+
+#endif  /* DOMAIN */
+/* Code from GRTE/v4 math.h */
+
+#endif // __LIBM_SPECIAL_H__
diff --git a/inc/libm_util_amd.h b/inc/libm_util_amd.h
new file mode 100644
index 0000000..f7347d0
--- /dev/null
+++ b/inc/libm_util_amd.h
@@ -0,0 +1,195 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifndef LIBM_UTIL_AMD_H_INCLUDED
+#define LIBM_UTIL_AMD_H_INCLUDED 1
+
+
+
+
+
+
+typedef float F32;
+typedef unsigned int U32;
+typedef int S32;
+
+typedef double F64;
+typedef unsigned long long  U64;
+typedef long long S64;
+
+union UT32_ 
+{
+    F32 f32;
+    U32 u32;
+};
+
+union UT64_ 
+{
+    F64 f64;
+    U64 u64;
+    
+    F32 f32[2];
+    U32 u32[2];
+};
+
+typedef union UT32_ UT32;
+typedef union UT64_ UT64;
+
+
+
+
+#define QNAN_MASK_32        0x00400000
+#define QNAN_MASK_64        0x0008000000000000
+
+
+#define MULTIPLIER_SP 24
+#define MULTIPLIER_DP 53
+
+static const double VAL_2PMULTIPLIER_DP =  9007199254740992.0;
+static const double VAL_2PMMULTIPLIER_DP = 1.1102230246251565404236316680908e-16;
+static const float VAL_2PMULTIPLIER_SP =  16777216.0F;
+static const float VAL_2PMMULTIPLIER_SP = 5.9604645e-8F;
+
+
+
+
+
+/* Definitions for double functions on 64 bit machines */
+#define SIGNBIT_DP64      0x8000000000000000
+#define EXPBITS_DP64      0x7ff0000000000000
+#define MANTBITS_DP64     0x000fffffffffffff
+#define ONEEXPBITS_DP64   0x3ff0000000000000
+#define TWOEXPBITS_DP64   0x4000000000000000
+#define HALFEXPBITS_DP64  0x3fe0000000000000
+#define IMPBIT_DP64       0x0010000000000000
+#define QNANBITPATT_DP64  0x7ff8000000000000
+#define INDEFBITPATT_DP64 0xfff8000000000000
+#define PINFBITPATT_DP64  0x7ff0000000000000
+#define NINFBITPATT_DP64  0xfff0000000000000
+#define EXPBIAS_DP64      1023
+#define EXPSHIFTBITS_DP64 52
+#define BIASEDEMIN_DP64   1
+#define EMIN_DP64         -1022
+#define BIASEDEMAX_DP64   2046
+#define EMAX_DP64         1023
+#define LAMBDA_DP64       1.0e300
+#define MANTLENGTH_DP64   53
+#define BASEDIGITS_DP64   15
+
+
+/* These definitions, used by float functions,
+   are for both 32 and 64 bit machines */
+#define SIGNBIT_SP32      0x80000000
+#define EXPBITS_SP32      0x7f800000
+#define MANTBITS_SP32     0x007fffff
+#define ONEEXPBITS_SP32   0x3f800000
+#define TWOEXPBITS_SP32   0x40000000
+#define HALFEXPBITS_SP32  0x3f000000
+#define IMPBIT_SP32       0x00800000
+#define QNANBITPATT_SP32  0x7fc00000
+#define INDEFBITPATT_SP32 0xffc00000
+#define PINFBITPATT_SP32  0x7f800000
+#define NINFBITPATT_SP32  0xff800000
+#define EXPBIAS_SP32      127
+#define EXPSHIFTBITS_SP32 23
+#define BIASEDEMIN_SP32   1
+#define EMIN_SP32         -126
+#define BIASEDEMAX_SP32   254
+#define EMAX_SP32         127
+#define LAMBDA_SP32       1.0e30
+#define MANTLENGTH_SP32   24
+#define BASEDIGITS_SP32   7
+
+#define CLASS_SIGNALLING_NAN 1
+#define CLASS_QUIET_NAN 2
+#define CLASS_NEGATIVE_INFINITY 3
+#define CLASS_NEGATIVE_NORMAL_NONZERO 4
+#define CLASS_NEGATIVE_DENORMAL 5
+#define CLASS_NEGATIVE_ZERO 6
+#define CLASS_POSITIVE_ZERO 7
+#define CLASS_POSITIVE_DENORMAL 8
+#define CLASS_POSITIVE_NORMAL_NONZERO 9
+#define CLASS_POSITIVE_INFINITY 10
+
+#define OLD_BITS_SP32(x) (*((unsigned int *)&x))
+#define OLD_BITS_DP64(x) (*((unsigned long long *)&x))
+
+/* Alternatives to the above functions which don't have
+   problems when using high optimization levels on gcc */
+#define GET_BITS_SP32(x, ux) \
+  { \
+    volatile union {float f; unsigned int i;} _bitsy; \
+    _bitsy.f = (x); \
+    ux = _bitsy.i; \
+  }
+#define PUT_BITS_SP32(ux, x) \
+  { \
+    volatile union {float f; unsigned int i;} _bitsy; \
+    _bitsy.i = (ux); \
+     x = _bitsy.f; \
+  }
+
+#define GET_BITS_DP64(x, ux) \
+  { \
+    volatile union {double d; unsigned long long i;} _bitsy; \
+    _bitsy.d = (x); \
+    ux = _bitsy.i; \
+  }
+#define PUT_BITS_DP64(ux, x) \
+  { \
+    volatile union {double d; unsigned long long i;} _bitsy; \
+    _bitsy.i = (ux); \
+    x = _bitsy.d; \
+  }
+
+
+/* Processor-dependent floating-point status flags */
+#define AMD_F_INEXACT 0x00000020
+#define AMD_F_UNDERFLOW 0x00000010
+#define AMD_F_OVERFLOW 0x00000008
+#define AMD_F_DIVBYZERO 0x00000004
+#define AMD_F_INVALID 0x00000001
+
+/* Processor-dependent floating-point precision-control flags */
+#define AMD_F_EXTENDED 0x00000300
+#define AMD_F_DOUBLE   0x00000200
+#define AMD_F_SINGLE   0x00000000
+
+/* Processor-dependent floating-point rounding-control flags */
+#define AMD_F_RC_NEAREST 0x00000000
+#define AMD_F_RC_DOWN    0x00002000
+#define AMD_F_RC_UP      0x00004000
+#define AMD_F_RC_ZERO    0x00006000
+
+/* How to get hold of an assembly square root instruction:
+ *   ASMQRT(x,y) computes y = sqrt(x).
+ */
+#ifdef WINDOWS
+/* VC++ intrinsic call */
+#define ASMSQRT(x,y) _mm_store_sd(&y, _mm_sqrt_sd(_mm_setzero_pd(), _mm_load_sd(&x)));
+#else
+/* Hammer sqrt instruction */
+#define ASMSQRT(x,y) asm volatile ("sqrtsd %1, %0" : "=x" (y) : "x" (x));
+#endif
+
+#endif /* LIBM_UTIL_AMD_H_INCLUDED */
diff --git a/libacml.h b/libacml.h
new file mode 100644
index 0000000..92c2ccb
--- /dev/null
+++ b/libacml.h
@@ -0,0 +1,76 @@
+// Copyright 2010 and onwards Google Inc.
+// Author: Martin Thuresson
+//
+// Expose fast k8 implementation of math functions with the prefix
+// "acml_".  Currently acml_log(), acml_exp(), and acmp_pow() have
+// shown to have significantly better performance over glibc libm
+// and atleast as good precision.
+// https://wiki.corp.google.com/twiki/bin/view/Main/CompilerMathOptimization
+//
+// When build with --cpu=piii, acml_* will call the pure libm functions,
+// avoiding the need to special case the calls.
+//
+// TODO(martint): Update glibc to match the libacml performance.
+
+#ifndef THIRD_PARTY__OPEN64_LIBACML_MV__LIBACML_H_
+#define THIRD_PARTY__OPEN64_LIBACML_MV__LIBACML_H_
+
+#ifndef USE_LIBACML_IMPLEMENTATION
+#define USE_LIBACML_IMPLEMENTATION defined(__x86_64__)
+#endif
+
+#if USE_LIBACML_IMPLEMENTATION
+#include "third_party/open64_libacml_mv/inc/fn_macros.h"
+#else
+#include <math.h>
+#endif
+
+extern "C" {
+
+#if USE_LIBACML_IMPLEMENTATION
+// The k8 implementation of the math functions.
+#define acml_exp_k8 FN_PROTOTYPE(exp)
+#define acml_expf_k8 FN_PROTOTYPE(expf)
+#define acml_log_k8 FN_PROTOTYPE(log)
+#define acml_pow_k8 FN_PROTOTYPE(pow)
+double acml_exp_k8(double x);
+float acml_expf_k8(float x);
+double acml_log_k8(double x);
+double acml_pow_k8(double x, double y);
+#endif
+
+static inline double acml_exp(double x) {
+#if USE_LIBACML_IMPLEMENTATION
+  return acml_exp_k8(x);
+#else
+  return exp(x);
+#endif
+}
+
+static inline float acml_expf(float x) {
+#if USE_LIBACML_IMPLEMENTATION
+  return acml_expf_k8(x);
+#else
+  return expf(x);
+#endif
+}
+
+static inline double acml_log(double x) {
+#if USE_LIBACML_IMPLEMENTATION
+  return acml_log_k8(x);
+#else
+  return log(x);
+#endif
+}
+
+static inline double acml_pow(double x, double y) {
+#if USE_LIBACML_IMPLEMENTATION
+  return acml_pow_k8(x, y);
+#else
+  return pow(x, y);
+#endif
+}
+
+}
+
+#endif  // THIRD_PARTY__OPEN64_LIBACML_MV__LIBACML_H_
diff --git a/libacml_portability_test.cc b/libacml_portability_test.cc
new file mode 100644
index 0000000..1f62d1a
--- /dev/null
+++ b/libacml_portability_test.cc
@@ -0,0 +1,16 @@
+#include "testing/base/public/gmock.h"
+#include "testing/base/public/gunit.h"
+#include "third_party/open64_libacml_mv/libacml.h"
+
+namespace {
+
+using ::testing::Eq;
+
+TEST(LibacmlPortabilityTest, Trivial) {
+  EXPECT_THAT(acml_exp(0), Eq(1));
+  EXPECT_THAT(acml_expf(0), Eq(1));
+  EXPECT_THAT(acml_pow(2, 2), Eq(4));
+  EXPECT_THAT(acml_log(1), Eq(0));
+}
+
+}  // namespace
diff --git a/src/acos.c b/src/acos.c
new file mode 100644
index 0000000..26bac6c
--- /dev/null
+++ b/src/acos.c
@@ -0,0 +1,183 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#define USE_VAL_WITH_FLAGS
+#define USE_NAN_WITH_FLAGS
+#define USE_HANDLE_ERROR
+#include "../inc/libm_inlines_amd.h"
+#undef USE_NAN_WITH_FLAGS
+#undef USE_VAL_WITH_FLAGS
+#undef USE_HANDLE_ERROR
+
+#include "../inc/libm_errno_amd.h"
+
+#ifndef WINDOWS
+/* Deal with errno for out-of-range argument */
+static inline double retval_errno_edom(double x)
+{
+  struct exception exc;
+  exc.arg1 = x;
+  exc.arg2 = x;
+  exc.name = (char *)"acos";
+  exc.type = DOMAIN;
+  if (_LIB_VERSION == _SVID_)
+    exc.retval = HUGE;
+  else
+    exc.retval = nan_with_flags(AMD_F_INVALID);
+  if (_LIB_VERSION == _POSIX_)
+    __set_errno(EDOM);
+  else if (!matherr(&exc))
+    {
+      if(_LIB_VERSION == _SVID_)
+        (void)fputs("acos: DOMAIN error\n", stderr);
+    __set_errno(EDOM);
+    }
+  return exc.retval;
+}
+#endif
+
+#ifdef WINDOWS
+#pragma function(acos)
+#endif
+
+double FN_PROTOTYPE(acos)(double x)
+{
+  /* Computes arccos(x).
+     The argument is first reduced by noting that arccos(x)
+     is invalid for abs(x) > 1. For denormal and small
+     arguments arccos(x) = pi/2 to machine accuracy.
+     Remaining argument ranges are handled as follows.
+     For abs(x) <= 0.5 use
+     arccos(x) = pi/2 - arcsin(x)
+     = pi/2 - (x + x^3*R(x^2))
+     where R(x^2) is a rational minimax approximation to
+     (arcsin(x) - x)/x^3.
+     For abs(x) > 0.5 exploit the identity:
+     arccos(x) = pi - 2*arcsin(sqrt(1-x)/2)
+     together with the above rational approximation, and
+     reconstruct the terms carefully.
+  */
+
+  /* Some constants and split constants. */
+
+  static const double
+    pi         = 3.1415926535897933e+00, /* 0x400921fb54442d18 */
+    piby2      = 1.5707963267948965580e+00, /* 0x3ff921fb54442d18 */
+    piby2_head = 1.5707963267948965580e+00, /* 0x3ff921fb54442d18 */
+    piby2_tail = 6.12323399573676603587e-17; /* 0x3c91a62633145c07 */
+
+  double u, y, s=0.0, r;
+  int xexp, xnan, transform=0;
+
+  unsigned long long ux, aux, xneg;
+  GET_BITS_DP64(x, ux);
+  aux = ux & ~SIGNBIT_DP64;
+  xneg = (ux & SIGNBIT_DP64);
+  xnan = (aux > PINFBITPATT_DP64);
+  xexp = (int)((ux & EXPBITS_DP64) >> EXPSHIFTBITS_DP64) - EXPBIAS_DP64;
+
+  /* Special cases */
+
+  if (xnan)
+    {
+#ifdef WINDOWS
+      return handle_error("acos", ux|0x0008000000000000, _DOMAIN,
+                          0, EDOM, x, 0.0);
+#else
+      return x + x; /* With invalid if it's a signalling NaN */
+#endif
+    }
+  else if (xexp < -56)
+    { /* y small enough that arccos(x) = pi/2 */
+      return val_with_flags(piby2, AMD_F_INEXACT);
+    }
+  else if (xexp >= 0)
+    { /* abs(x) >= 1.0 */
+      if (x == 1.0)
+        return 0.0;
+      else if (x == -1.0)
+        return val_with_flags(pi, AMD_F_INEXACT);
+      else
+#ifdef WINDOWS
+        return handle_error("acos", INDEFBITPATT_DP64, _DOMAIN,
+                            AMD_F_INVALID, EDOM, x, 0.0);
+#else
+        return retval_errno_edom(x);
+#endif
+    }
+
+  if (xneg) y = -x;
+  else y = x;
+
+  transform = (xexp >= -1); /* abs(x) >= 0.5 */
+
+  if (transform)
+    { /* Transform y into the range [0,0.5) */
+      r = 0.5*(1.0 - y);
+#ifdef WINDOWS
+      /* VC++ intrinsic call */
+      _mm_store_sd(&s, _mm_sqrt_sd(_mm_setzero_pd(), _mm_load_sd(&r)));
+#else
+      /* Hammer sqrt instruction */
+      asm volatile ("sqrtsd %1, %0" : "=x" (s) : "x" (r));
+#endif
+      y = s;
+    }
+  else
+    r = y*y;
+
+  /* Use a rational approximation for [0.0, 0.5] */
+
+  u = r*(0.227485835556935010735943483075 +
+         (-0.445017216867635649900123110649 +
+          (0.275558175256937652532686256258 +
+           (-0.0549989809235685841612020091328 +
+            (0.00109242697235074662306043804220 +
+             0.0000482901920344786991880522822991*r)*r)*r)*r)*r)/
+    (1.36491501334161032038194214209 +
+     (-3.28431505720958658909889444194 +
+      (2.76568859157270989520376345954 +
+       (-0.943639137032492685763471240072 +
+	0.105869422087204370341222318533*r)*r)*r)*r);
+
+  if (transform)
+    { /* Reconstruct acos carefully in transformed region */
+      if (xneg) return pi - 2.0*(s+(y*u - piby2_tail));
+      else
+	{
+	  double c, s1;
+	  unsigned long long us;
+	  GET_BITS_DP64(s, us);
+	  PUT_BITS_DP64(0xffffffff00000000 & us, s1);
+	  c = (r-s1*s1)/(s+s1);
+          return 2.0*s1 + (2.0*c+2.0*y*u);
+	}
+    }
+  else
+    return piby2_head - (x - (piby2_tail - x*u));
+}
+
+weak_alias (__acos, acos)
diff --git a/src/acosf.c b/src/acosf.c
new file mode 100644
index 0000000..4464661
--- /dev/null
+++ b/src/acosf.c
@@ -0,0 +1,181 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#define USE_VALF_WITH_FLAGS
+#define USE_NANF_WITH_FLAGS
+#define USE_HANDLE_ERRORF
+#include "../inc/libm_inlines_amd.h"
+#undef USE_NANF_WITH_FLAGS
+#undef USE_VALF_WITH_FLAGS
+#undef USE_HANDLE_ERRORF
+
+#include "../inc/libm_errno_amd.h"
+
+#ifndef WINDOWS
+/* Deal with errno for out-of-range argument */
+static inline float retval_errno_edom(float x)
+{
+  struct exception exc;
+  exc.arg1 = (double)x;
+  exc.arg2 = (double)x;
+  exc.name = (char *)"acosf";
+  exc.type = DOMAIN;
+  if (_LIB_VERSION == _SVID_)
+    exc.retval = HUGE;
+  else
+    exc.retval = nanf_with_flags(AMD_F_INVALID);
+  if (_LIB_VERSION == _POSIX_)
+    __set_errno(EDOM);
+  else if (!matherr(&exc))
+    {
+      if(_LIB_VERSION == _SVID_)
+        (void)fputs("acosf: DOMAIN error\n", stderr);
+    __set_errno(EDOM);
+    }
+  return exc.retval;
+}
+#endif
+
+#ifdef WINDOWS
+#pragma function(acosf)
+#endif
+
+float FN_PROTOTYPE(acosf)(float x)
+{
+  /* Computes arccos(x).
+     The argument is first reduced by noting that arccos(x)
+     is invalid for abs(x) > 1. For denormal and small
+     arguments arccos(x) = pi/2 to machine accuracy.
+     Remaining argument ranges are handled as follows.
+     For abs(x) <= 0.5 use
+     arccos(x) = pi/2 - arcsin(x)
+     = pi/2 - (x + x^3*R(x^2))
+     where R(x^2) is a rational minimax approximation to
+     (arcsin(x) - x)/x^3.
+     For abs(x) > 0.5 exploit the identity:
+     arccos(x) = pi - 2*arcsin(sqrt(1-x)/2)
+     together with the above rational approximation, and
+     reconstruct the terms carefully.
+  */
+
+  /* Some constants and split constants. */
+
+  static const float
+    piby2      = 1.5707963705e+00F; /* 0x3fc90fdb */
+  static const double
+    pi         = 3.1415926535897933e+00, /* 0x400921fb54442d18 */
+    piby2_head = 1.5707963267948965580e+00, /* 0x3ff921fb54442d18 */
+    piby2_tail = 6.12323399573676603587e-17; /* 0x3c91a62633145c07 */
+
+  float u, y, s = 0.0F, r;
+  int xexp, xnan, transform = 0;
+
+  unsigned int ux, aux, xneg;
+
+  GET_BITS_SP32(x, ux);
+  aux = ux & ~SIGNBIT_SP32;
+  xneg = (ux & SIGNBIT_SP32);
+  xnan = (aux > PINFBITPATT_SP32);
+  xexp = (int)((ux & EXPBITS_SP32) >> EXPSHIFTBITS_SP32) - EXPBIAS_SP32;
+
+  /* Special cases */
+
+  if (xnan)
+    {
+#ifdef WINDOWS
+      return handle_errorf("acosf", ux|0x00400000, _DOMAIN, 0,
+                           EDOM, x, 0.0F);
+#else
+      return x + x; /* With invalid if it's a signalling NaN */
+#endif
+    }
+  else if (xexp < -26)
+    /* y small enough that arccos(x) = pi/2 */
+    return valf_with_flags(piby2, AMD_F_INEXACT);
+  else if (xexp >= 0)
+    { /* abs(x) >= 1.0 */
+      if (x == 1.0F)
+        return 0.0F;
+      else if (x == -1.0F)
+        return valf_with_flags((float)pi, AMD_F_INEXACT);
+      else
+#ifdef WINDOWS
+        return handle_errorf("acosf", INDEFBITPATT_SP32, _DOMAIN,
+                             AMD_F_INVALID, EDOM, x, 0.0F);
+#else
+        return retval_errno_edom(x);
+#endif
+    }
+
+  if (xneg) y = -x;
+  else y = x;
+
+  transform = (xexp >= -1); /* abs(x) >= 0.5 */
+
+  if (transform)
+    { /* Transform y into the range [0,0.5) */
+      r = 0.5F*(1.0F - y);
+#ifdef WINDOWS
+      /* VC++ intrinsic call */
+      _mm_store_ss(&s, _mm_sqrt_ss(_mm_load_ss(&r)));
+#else
+      /* Hammer sqrt instruction */
+      asm volatile ("sqrtss %1, %0" : "=x" (s) : "x" (r));
+#endif
+      y = s;
+    }
+  else
+    r = y*y;
+
+  /* Use a rational approximation for [0.0, 0.5] */
+
+  u=r*(0.184161606965100694821398249421F +
+       (-0.0565298683201845211985026327361F +
+	(-0.0133819288943925804214011424456F -
+	 0.00396137437848476485201154797087F*r)*r)*r)/
+    (1.10496961524520294485512696706F -
+     0.836411276854206731913362287293F*r);
+
+  if (transform)
+    {
+      /* Reconstruct acos carefully in transformed region */
+      if (xneg)
+        return (float)(pi - 2.0*(s+(y*u - piby2_tail)));
+      else
+	{
+	  float c, s1;
+	  unsigned int us;
+	  GET_BITS_SP32(s, us);
+	  PUT_BITS_SP32(0xffff0000 & us, s1);
+	  c = (r-s1*s1)/(s+s1);
+          return 2.0F*s1 + (2.0F*c+2.0F*y*u);
+	}
+    }
+  else
+    return (float)(piby2_head - (x - (piby2_tail - x*u)));
+}
+
+weak_alias (__acosf, acosf)
diff --git a/src/acosh.c b/src/acosh.c
new file mode 100644
index 0000000..f1d62c6
--- /dev/null
+++ b/src/acosh.c
@@ -0,0 +1,447 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#define USE_NAN_WITH_FLAGS
+#define USE_HANDLE_ERROR
+#define USE_LOG_KERNEL_AMD
+#include "../inc/libm_inlines_amd.h"
+#undef USE_NAN_WITH_FLAGS
+#undef USE_HANDLE_ERROR
+#undef USE_LOG_KERNEL_AMD
+
+#include "../inc/libm_errno_amd.h"
+
+#ifndef WINDOWS
+/* Deal with errno for out-of-range argument */
+static inline double retval_errno_edom(double x)
+{
+  struct exception exc;
+  exc.arg1 = x;
+  exc.arg2 = x;
+  exc.type = DOMAIN;
+  exc.name = (char *)"acosh";
+  if (_LIB_VERSION == _SVID_)
+    exc.retval = -HUGE;
+  else
+    exc.retval = nan_with_flags(AMD_F_INVALID);
+  if (_LIB_VERSION == _POSIX_)
+    __set_errno(EDOM);
+  else if (!matherr(&exc))
+    {
+      if(_LIB_VERSION == _SVID_)
+        (void)fputs("acosh: DOMAIN error\n", stderr);
+    __set_errno(EDOM);
+    }
+  return exc.retval;
+}
+#endif
+
+#undef _FUNCNAME
+#define _FUNCNAME "acosh"
+double FN_PROTOTYPE(acosh)(double x)
+{
+
+  unsigned long long ux;
+  double r, rarg, r1, r2;
+  int xexp;
+
+  static const unsigned long long
+    recrteps = 0x4196a09e667f3bcd; /* 1/sqrt(eps) = 9.49062656242515593767e+07 */
+  /* log2_lead and log2_tail sum to an extra-precise version
+     of log(2) */
+
+  static const double
+    log2_lead = 6.93147122859954833984e-01,  /* 0x3fe62e42e0000000 */
+    log2_tail = 5.76999904754328540596e-08;  /* 0x3e6efa39ef35793c */
+
+
+  GET_BITS_DP64(x, ux);
+
+  if ((ux & EXPBITS_DP64) == EXPBITS_DP64)
+    {
+      /* x is either NaN or infinity */
+      if (ux & MANTBITS_DP64)
+        {
+          /* x is NaN */
+#ifdef WINDOWS
+          return handle_error(_FUNCNAME, ux|0x0008000000000000, _DOMAIN,
+                              AMD_F_INVALID, EDOM, x, 0.0);
+#else
+          return x + x; /* Raise invalid if it is a signalling NaN */
+#endif
+        }
+      else
+        {
+          /* x is infinity */
+          if (ux & SIGNBIT_DP64)
+            /* x is negative infinity. Return a NaN. */
+#ifdef WINDOWS
+            return handle_error(_FUNCNAME, INDEFBITPATT_DP64, _DOMAIN,
+                                AMD_F_INVALID, EDOM, x, 0.0);
+#else
+            return retval_errno_edom(x);
+#endif
+          else
+            /* Return positive infinity with no signal */
+            return x;
+        }
+    }
+  else if ((ux & SIGNBIT_DP64) || (ux <= 0x3ff0000000000000))
+    {
+      /* x <= 1.0 */
+      if (ux == 0x3ff0000000000000)
+        {
+          /* x = 1.0; return zero. */
+          return 0.0;
+        }
+      else
+        {
+          /* x is less than 1.0. Return a NaN. */
+#ifdef WINDOWS
+          return handle_error(_FUNCNAME, INDEFBITPATT_DP64, _DOMAIN,
+                              AMD_F_INVALID, EDOM, x, 0.0);
+#else
+          return retval_errno_edom(x);
+#endif
+        }
+    }
+
+
+  if (ux > recrteps)
+    {
+      /* Arguments greater than 1/sqrt(epsilon) in magnitude are
+         approximated by acosh(x) = ln(2) + ln(x) */
+      /* log_kernel_amd(x) returns xexp, r1, r2 such that
+         log(x) = xexp*log(2) + r1 + r2 */
+      log_kernel_amd64(x, ux, &xexp, &r1, &r2);
+      /* Add (xexp+1) * log(2) to z1,z2 to get the result acosh(x).
+         The computed r1 is not subject to rounding error because
+         (xexp+1) has at most 10 significant bits, log(2) has 24 significant
+         bits, and r1 has up to 24 bits; and the exponents of r1
+         and r2 differ by at most 6. */
+      r1 = ((xexp+1) * log2_lead + r1);
+      r2 = ((xexp+1) * log2_tail + r2);
+      return r1 + r2;
+    }
+  else if (ux >= 0x4060000000000000)
+    {
+      /* 128.0 <= x <= 1/sqrt(epsilon) */
+      /* acosh for these arguments is approximated by
+         acosh(x) = ln(x + sqrt(x*x-1)) */
+      rarg = x*x-1.0;
+      /* Use assembly instruction to compute r = sqrt(rarg); */
+      ASMSQRT(rarg,r);
+      r += x;
+      GET_BITS_DP64(r, ux);
+      log_kernel_amd64(r, ux, &xexp, &r1, &r2);
+      r1 = (xexp * log2_lead + r1);
+      r2 = (xexp * log2_tail + r2);
+      return r1 + r2;
+    }
+  else
+    {
+      /* 1.0 < x <= 128.0 */
+      double u1, u2, v1, v2, w1, w2, hx, tx, t, r, s, p1, p2, a1, a2, c1, c2,
+        poly;
+      if (ux >= 0x3ff8000000000000)
+        {
+          /* 1.5 <= x <= 128.0 */
+          /* We use minimax polynomials,
+             based on Abramowitz and Stegun 4.6.32 series
+             expansion for acosh(x), with the log(2x) and 1/(2.2.x^2)
+             terms removed. We compensate for these two terms later.
+          */
+          t = x*x;
+          if (ux >= 0x4040000000000000)
+            {
+              /* [3,2] for 32.0 <= x <= 128.0 */
+              poly =
+                (0.45995704464157438175e-9 +
+                 (-0.89080839823528631030e-9 +
+                  (-0.10370522395596168095e-27 +
+                   0.35255386405811106347e-32 * t) * t) * t) /
+                (0.21941191335882074014e-8 +
+                 (-0.10185073058358334569e-7 +
+                  0.95019562478430648685e-8 * t) * t);
+            }
+          else if (ux >= 0x4020000000000000)
+            {
+              /* [3,3] for 8.0 <= x <= 32.0 */
+              poly =
+                (-0.54903656589072526589e-10 +
+                 (0.27646792387218569776e-9 +
+                  (-0.26912957240626571979e-9 -
+                   0.86712268396736384286e-29 * t) * t) * t) /
+                (-0.24327683788655520643e-9 +
+                 (0.20633757212593175571e-8 +
+                  (-0.45438330985257552677e-8 +
+                   0.28707154390001678580e-8 * t) * t) * t);
+            }
+          else if (ux >= 0x4010000000000000)
+            {
+              /* [4,3] for 4.0 <= x <= 8.0 */
+              poly =
+                (-0.20827370596738166108e-6 +
+                 (0.10232136919220422622e-5 +
+                  (-0.98094503424623656701e-6 +
+                   (-0.11615338819596146799e-18 +
+                    0.44511847799282297160e-21 * t) * t) * t) * t) /
+                (-0.92579451630913718588e-6 +
+                 (0.76997374707496606639e-5 +
+                  (-0.16727286999128481170e-4 +
+                   0.10463413698762590251e-4 * t) * t) * t);
+            }
+          else if (ux >= 0x4000000000000000)
+            {
+              /* [5,5] for 2.0 <= x <= 4.0 */
+              poly =
+                (-0.122195030526902362060e-7 +
+                 (0.157894522814328933143e-6 +
+                  (-0.579951798420930466109e-6 +
+                   (0.803568881125803647331e-6 +
+                    (-0.373906657221148667374e-6 -
+                     0.317856399083678204443e-21 * t) * t) * t) * t) * t) /
+                (-0.516260096352477148831e-7 +
+                 (0.894662592315345689981e-6 +
+                  (-0.475662774453078218581e-5 +
+                   (0.107249291567405130310e-4 +
+                    (-0.107871445525891289759e-4 +
+                     0.398833767702587224253e-5 * t) * t) * t) * t) * t);
+            }
+          else if (ux >= 0x3ffc000000000000)
+            {
+              /* [5,4] for 1.75 <= x <= 2.0 */
+              poly =
+                (0.1437926821253825186e-3 +
+                 (-0.1034078230246627213e-2 +
+                  (0.2015310005461823437e-2 +
+                   (-0.1159685218876828075e-2 +
+                    (-0.9267353551307245327e-11 +
+                     0.2880267770324388034e-12 * t) * t) * t) * t) * t) /
+                (0.6305521447028109891e-3 +
+                 (-0.6816525887775002944e-2 +
+                  (0.2228081831550003651e-1 +
+                   (-0.2836886105406603318e-1 +
+                    0.1236997707206036752e-1 * t) * t) * t) * t);
+            }
+          else
+            {
+              /* [5,4] for 1.5 <= x <= 1.75 */
+              poly =
+                ( 0.7471936607751750826e-3 +
+                  (-0.4849405284371905506e-2 +
+                   (0.8823068059778393019e-2 +
+                    (-0.4825395461288629075e-2 +
+                     (-0.1001984320956564344e-8 +
+                      0.4299919281586749374e-10 * t) * t) * t) * t) * t) /
+                (0.3322359141239411478e-2 +
+                 (-0.3293525930397077675e-1 +
+                  (0.1011351440424239210e0 +
+                   (-0.1227083591622587079e0 +
+                    0.5147099404383426080e-1 * t) * t) * t) * t);
+            }
+          GET_BITS_DP64(x, ux);
+          log_kernel_amd64(x, ux, &xexp, &r1, &r2);
+          r1 = ((xexp+1) * log2_lead + r1);
+          r2 = ((xexp+1) * log2_tail + r2);
+          /* Now (r1,r2) sum to log(2x). Subtract the term
+             1/(2.2.x^2) = 0.25/t, and add poly/t, carefully
+             to maintain precision. (Note that we add poly/t
+             rather than poly because of the *x factor used
+             when generating the minimax polynomial) */
+          v2 = (poly-0.25)/t;
+          r = v2 + r1;
+          s = ((r1 - r) + v2) + r2;
+          v1 = r + s;
+          return v1 + ((r - v1) + s);
+        }
+
+      /* Here 1.0 <= x <= 1.5. It is hard to maintain accuracy here so
+         we have to go to great lengths to do so. */
+
+      /* We compute the value
+           t = x - 1.0 + sqrt(2.0*(x - 1.0) + (x - 1.0)*(x - 1.0))
+         using simulated quad precision. */
+      t = x - 1.0;
+      u1 = t * 2.0;
+
+      /* dekker_mul12(t,t,&v1,&v2); */
+      GET_BITS_DP64(t, ux);
+      ux &= 0xfffffffff8000000;
+      PUT_BITS_DP64(ux, hx);
+      tx = t - hx;
+      v1 = t * t;
+      v2 = (((hx * hx - v1) + hx * tx) + tx * hx) + tx * tx;
+
+      /* dekker_add2(u1,0.0,v1,v2,&w1,&w2); */
+      r = u1 + v1;
+      s = (((u1 - r) + v1) + v2);
+      w1 = r + s;
+      w2 = (r - w1) + s;
+
+      /* dekker_sqrt2(w1,w2,&u1,&u2); */
+      ASMSQRT(w1,p1);
+      GET_BITS_DP64(p1, ux);
+      ux &= 0xfffffffff8000000;
+      PUT_BITS_DP64(ux, c1);
+      c2 = p1 - c1;
+      a1 = p1 * p1;
+      a2 = (((c1 * c1 - a1) + c1 * c2) + c2 * c1) + c2 * c2;
+      p2 = (((w1 - a1) - a2) + w2) * 0.5 / p1;
+      u1 = p1 + p2;
+      u2 = (p1 - u1) + p2;
+
+      /* dekker_add2(u1,u2,t,0.0,&v1,&v2); */
+      r = u1 + t;
+      s = (((u1 - r) + t)) + u2;
+      r1 = r + s;
+      r2 = (r - r1) + s;
+      t = r1 + r2;
+
+      /* Check for x close to 1.0. */
+      if (x < 1.13)
+        {
+          /* Here 1.0 <= x < 1.13 implies r <= 0.656. In this region
+             we need to take extra care to maintain precision.
+             We have t = r1 + r2 = (x - 1.0 + sqrt(x*x-1.0))
+             to more than basic precision. We use the Taylor series
+             for log(1+x), with terms after the O(x*x) term
+             approximated by a [6,6] minimax polynomial. */
+          double b1, b2, c1, c2, e1, e2, q1, q2, c, cc, hr1, tr1, hpoly, tpoly, hq1, tq1, hr2, tr2;
+          poly =
+            (0.30893760556597282162e-21 +
+             (0.10513858797132174471e0 +
+              (0.27834538302122012381e0 +
+               (0.27223638654807468186e0 +
+                (0.12038958198848174570e0 +
+                 (0.23357202004546870613e-1 +
+                  (0.15208417992520237648e-2 +
+                   0.72741030690878441996e-7 * t) * t) * t) * t) * t) * t) * t) /
+            (0.31541576391396523486e0 +
+             (0.10715979719991342022e1 +
+              (0.14311581802952004012e1 +
+               (0.94928647994421895988e0 +
+                (0.32396235926176348977e0 +
+                 (0.52566134756985833588e-1 +
+                  0.30477895574211444963e-2 * t) * t) * t) * t) * t) * t);
+
+          /* Now we can compute the result r = acosh(x) = log1p(t)
+             using the formula t - 0.5*t*t + poly*t*t. Since t is
+             represented as r1+r2, the formula becomes
+             r = r1+r2 - 0.5*(r1+r2)*(r1+r2) + poly*(r1+r2)*(r1+r2).
+             Expanding out, we get
+               r = r1 + r2 - (0.5 + poly)*(r1*r1 + 2*r1*r2 + r2*r2)
+             and ignoring negligible quantities we get
+               r = r1 + r2 - 0.5*r1*r1 + r1*r2 + poly*t*t
+          */
+          if (x < 1.06)
+            {
+              double b, c, e;
+              b = r1*r2;
+              c = 0.5*r1*r1;
+              e = poly*t*t;
+              /* N.B. the order of additions and subtractions is important */
+              r = (((r2 - b) + e) - c) + r1;
+              return r;
+            }
+          else
+            {
+              /* For 1.06 <= x <= 1.13 we must evaluate in extended precision
+                 to reach about 1 ulp accuracy (in this range the simple code
+                 above only manages about 1.5 ulp accuracy) */
+
+              /* Split poly, r1 and r2 into head and tail sections */
+              GET_BITS_DP64(poly, ux);
+              ux &= 0xfffffffff8000000;
+              PUT_BITS_DP64(ux,hpoly);
+              tpoly = poly - hpoly;
+              GET_BITS_DP64(r1,ux);
+              ux &= 0xfffffffff8000000;
+              PUT_BITS_DP64(ux,hr1);
+              tr1 = r1 - hr1;
+              GET_BITS_DP64(r2, ux);
+              ux &= 0xfffffffff8000000;
+              PUT_BITS_DP64(ux,hr2);
+              tr2 = r2 - hr2;
+
+              /* e = poly*t*t */
+              c = poly * r1;
+              cc = (((hpoly * hr1 - c) + hpoly * tr1) + tpoly * hr1) + tpoly * tr1;
+              cc = poly * r2 + cc;
+              q1 = c + cc;
+              q2 = (c - q1) + cc;
+              GET_BITS_DP64(q1, ux);
+              ux &= 0xfffffffff8000000;
+              PUT_BITS_DP64(ux,hq1);
+              tq1 = q1 - hq1;
+              c = q1 * r1;
+              cc = (((hq1 * hr1 - c) + hq1 * tr1) + tq1 * hr1) + tq1 * tr1;
+              cc = q1 * r2 + q2 * r1 + cc;
+              e1 = c + cc;
+              e2 = (c - e1) + cc;
+
+              /* b = r1*r2 */
+              b1 = r1 * r2;
+              b2 = (((hr1 * hr2 - b1) + hr1 * tr2) + tr1 * hr2) + tr1 * tr2;
+
+              /* c = 0.5*r1*r1 */
+              c1 = (0.5*r1) * r1;
+              c2 = (((0.5*hr1 * hr1 - c1) + 0.5*hr1 * tr1) + 0.5*tr1 * hr1) + 0.5*tr1 * tr1;
+
+              /* v = a + d - b */
+              r = r1 - b1;
+              s = (((r1 - r) - b1) - b2) + r2;
+              v1 = r + s;
+              v2 = (r - v1) + s;
+
+              /* w = (a + d - b) - c */
+              r = v1 - c1;
+              s = (((v1 - r) - c1) - c2) + v2;
+              w1 = r + s;
+              w2 = (r - w1) + s;
+
+              /* u = ((a + d - b) - c) + e */
+              r = w1 + e1;
+              s = (((w1 - r) + e1) + e2) + w2;
+              u1 = r + s;
+              u2 = (r - u1) + s;
+
+              /* The result r = acosh(x) */
+              r = u1 + u2;
+
+              return r;
+            }
+        }
+      else
+        {
+          /* For arguments 1.13 <= x <= 1.5 the log1p function
+             is good enough */
+            return FN_PROTOTYPE(log1p)(t);
+        }
+    }
+}
+
+weak_alias (__acosh, acosh)
diff --git a/src/acoshf.c b/src/acoshf.c
new file mode 100644
index 0000000..c96fdb0
--- /dev/null
+++ b/src/acoshf.c
@@ -0,0 +1,149 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#include <stdio.h>
+
+#define USE_NANF_WITH_FLAGS
+#define USE_HANDLE_ERRORF
+#include "../inc/libm_inlines_amd.h"
+#undef USE_NANF_WITH_FLAGS
+#undef USE_HANDLE_ERRORF
+
+#include "../inc/libm_errno_amd.h"
+
+#ifndef WINDOWS
+/* Deal with errno for out-of-range argument */
+static inline float retval_errno_edom(float x)
+{
+  struct exception exc;
+  exc.arg1 = (double)x;
+  exc.arg2 = (double)x;
+  exc.type = DOMAIN;
+  exc.name = (char *)"acoshf";
+  if (_LIB_VERSION == _SVID_)
+    exc.retval = -HUGE;
+  else
+    exc.retval = nanf_with_flags(AMD_F_INVALID);
+  if (_LIB_VERSION == _POSIX_)
+    __set_errno(EDOM);
+  else if (!matherr(&exc))
+    {
+      if(_LIB_VERSION == _SVID_)
+        (void)fputs("acoshf: DOMAIN error\n", stderr);
+    __set_errno(EDOM);
+    }
+  return exc.retval;
+}
+#endif
+
+#undef _FUNCNAME
+#define _FUNCNAME "acoshf"
+float FN_PROTOTYPE(acoshf)(float x)
+{
+
+  unsigned int ux;
+  double dx, r, rarg, t;
+
+  static const unsigned int
+    recrteps = 0x46000000; /* 1/sqrt(eps) = 4.09600000000000000000e+03 */
+
+  static const double
+    log2 = 6.93147180559945286227e-01;  /* 0x3fe62e42fefa39ef */
+
+  GET_BITS_SP32(x, ux);
+
+  if ((ux & EXPBITS_SP32) == EXPBITS_SP32)
+    {
+      /* x is either NaN or infinity */
+      if (ux & MANTBITS_SP32)
+        {
+          /* x is NaN */
+#ifdef WINDOWS
+          return handle_errorf(_FUNCNAME, ux|0x00400000, _DOMAIN,
+                               0, EDOM, x, 0.0F);
+#else
+          return x + x; /* Raise invalid if it is a signalling NaN */
+#endif
+        }
+      else
+        {
+          /* x is infinity */
+          if (ux & SIGNBIT_SP32)
+            /* x is negative infinity. Return a NaN. */
+#ifdef WINDOWS
+            return handle_errorf(_FUNCNAME, INDEFBITPATT_SP32, _DOMAIN,
+                                 AMD_F_INVALID, EDOM, x, 0.0F);
+#else
+            return retval_errno_edom(x);
+#endif
+          else
+            /* Return positive infinity with no signal */
+            return x;
+        }
+    }
+  else if ((ux & SIGNBIT_SP32) || (ux < 0x3f800000))
+    {
+      /* x is less than 1.0. Return a NaN. */
+#ifdef WINDOWS
+      return handle_errorf(_FUNCNAME, INDEFBITPATT_SP32, _DOMAIN,
+                           AMD_F_INVALID, EDOM, x, 0.0F);
+#else
+      return retval_errno_edom(x);
+#endif
+    }
+
+  dx = x;
+
+  if (ux > recrteps)
+    {
+      /* Arguments greater than 1/sqrt(epsilon) in magnitude are
+         approximated by acoshf(x) = ln(2) + ln(x) */
+      r = FN_PROTOTYPE(log)(dx) + log2;
+    }
+  else if (ux > 0x40000000)
+    {
+      /* 2.0 <= x <= 1/sqrt(epsilon) */
+      /* acoshf for these arguments is approximated by
+         acoshf(x) = ln(x + sqrt(x*x-1)) */
+      rarg = dx*dx-1.0;
+      /* Use assembly instruction to compute r = sqrt(rarg); */
+      ASMSQRT(rarg,r);
+      rarg = r + dx;
+      r = FN_PROTOTYPE(log)(rarg);
+    }
+  else
+    {
+      /* sqrt(epsilon) <= x <= 2.0 */
+      t = dx - 1.0;
+      rarg = 2.0*t + t*t;
+      ASMSQRT(rarg,r);  /* r = sqrt(rarg) */
+      rarg = t + r;
+      r = FN_PROTOTYPE(log1p)(rarg);
+    }
+  return (float)(r);
+}
+
+weak_alias (__acoshf, acoshf)
diff --git a/src/asin.c b/src/asin.c
new file mode 100644
index 0000000..0314dd8
--- /dev/null
+++ b/src/asin.c
@@ -0,0 +1,196 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#define USE_VAL_WITH_FLAGS
+#define USE_NAN_WITH_FLAGS
+#define USE_HANDLE_ERROR
+#include "../inc/libm_inlines_amd.h"
+#undef USE_NAN_WITH_FLAGS
+#undef USE_VAL_WITH_FLAGS
+#undef USE_HANDLE_ERROR
+
+#include "../inc/libm_errno_amd.h"
+
+#ifndef WINDOWS
+/* Deal with errno for out-of-range argument */
+static inline double retval_errno_edom(double x)
+{
+  struct exception exc;
+  exc.arg1 = x;
+  exc.arg2 = x;
+  exc.type = DOMAIN;
+  exc.name = (char *)"asin";
+  if (_LIB_VERSION == _SVID_)
+    exc.retval = HUGE;
+  else
+    exc.retval = nan_with_flags(AMD_F_INVALID);
+  if (_LIB_VERSION == _POSIX_)
+    __set_errno(EDOM);
+  else if (!matherr(&exc))
+    {
+      if(_LIB_VERSION == _SVID_)
+        (void)fputs("asin: DOMAIN error\n", stderr);
+    __set_errno(EDOM);
+    }
+  return exc.retval;
+}
+#endif
+
+#ifdef WINDOWS
+#pragma function(asin)
+#endif
+
+double FN_PROTOTYPE(asin)(double x)
+{
+  /* Computes arcsin(x).
+     The argument is first reduced by noting that arcsin(x)
+     is invalid for abs(x) > 1 and arcsin(-x) = -arcsin(x).
+     For denormal and small arguments arcsin(x) = x to machine
+     accuracy. Remaining argument ranges are handled as follows.
+     For abs(x) <= 0.5 use
+     arcsin(x) = x + x^3*R(x^2)
+     where R(x^2) is a rational minimax approximation to
+     (arcsin(x) - x)/x^3.
+     For abs(x) > 0.5 exploit the identity:
+      arcsin(x) = pi/2 - 2*arcsin(sqrt(1-x)/2)
+     together with the above rational approximation, and
+     reconstruct the terms carefully.
+    */
+
+  /* Some constants and split constants. */
+
+  static const double
+    piby2_tail  = 6.1232339957367660e-17, /* 0x3c91a62633145c07 */
+    hpiby2_head = 7.8539816339744831e-01, /* 0x3fe921fb54442d18 */
+    piby2       = 1.5707963267948965e+00; /* 0x3ff921fb54442d18 */
+  double u, v, y, s=0.0, r;
+  int xexp, xnan, transform=0;
+
+  unsigned long long ux, aux, xneg;
+  GET_BITS_DP64(x, ux);
+  aux = ux & ~SIGNBIT_DP64;
+  xneg = (ux & SIGNBIT_DP64);
+  xnan = (aux > PINFBITPATT_DP64);
+  xexp = (int)((ux & EXPBITS_DP64) >> EXPSHIFTBITS_DP64) - EXPBIAS_DP64;
+
+  /* Special cases */
+
+  if (xnan)
+    {
+#ifdef WINDOWS
+      return handle_error("asin", ux|0x0008000000000000, _DOMAIN,
+                          0, EDOM, x, 0.0);
+#else
+      return x + x; /* With invalid if it's a signalling NaN */
+#endif
+    }
+  else if (xexp < -28)
+    { /* y small enough that arcsin(x) = x */
+      return val_with_flags(x, AMD_F_INEXACT);
+    }
+  else if (xexp >= 0)
+    { /* abs(x) >= 1.0 */
+      if (x == 1.0)
+        return val_with_flags(piby2, AMD_F_INEXACT);
+      else if (x == -1.0)
+        return val_with_flags(-piby2, AMD_F_INEXACT);
+      else
+#ifdef WINDOWS
+        return handle_error("asin", INDEFBITPATT_DP64, _DOMAIN,
+                            AMD_F_INVALID, EDOM, x, 0.0);
+#else
+        return retval_errno_edom(x);
+#endif
+    }
+
+  if (xneg) y = -x;
+  else y = x;
+
+  transform = (xexp >= -1); /* abs(x) >= 0.5 */
+
+  if (transform)
+    { /* Transform y into the range [0,0.5) */
+      r = 0.5*(1.0 - y);
+#ifdef WINDOWS
+      /* VC++ intrinsic call */
+      _mm_store_sd(&s, _mm_sqrt_sd(_mm_setzero_pd(), _mm_load_sd(&r)));
+#else
+      /* Hammer sqrt instruction */
+      asm volatile ("sqrtsd %1, %0" : "=x" (s) : "x" (r));
+#endif
+      y = s;
+    }
+  else
+    r = y*y;
+
+  /* Use a rational approximation for [0.0, 0.5] */
+
+  u = r*(0.227485835556935010735943483075 +
+         (-0.445017216867635649900123110649 +
+          (0.275558175256937652532686256258 +
+           (-0.0549989809235685841612020091328 +
+            (0.00109242697235074662306043804220 +
+             0.0000482901920344786991880522822991*r)*r)*r)*r)*r)/
+    (1.36491501334161032038194214209 +
+     (-3.28431505720958658909889444194 +
+      (2.76568859157270989520376345954 +
+       (-0.943639137032492685763471240072 +
+        0.105869422087204370341222318533*r)*r)*r)*r);
+
+  if (transform)
+    { /* Reconstruct asin carefully in transformed region */
+        {
+          double c, s1, p, q;
+          unsigned long long us;
+          GET_BITS_DP64(s, us);
+          PUT_BITS_DP64(0xffffffff00000000 & us, s1);
+          c = (r-s1*s1)/(s+s1);
+          p = 2.0*s*u - (piby2_tail-2.0*c);
+          q = hpiby2_head - 2.0*s1;
+          v = hpiby2_head - (p-q);
+        }
+    }
+  else
+    {
+#ifdef WINDOWS
+      /* Use a temporary variable to prevent VC++ rearranging
+            y + y*u
+         into
+            y * (1 + u)
+         and getting an incorrectly rounded result */
+      double tmp;
+      tmp = y * u;
+      v = y + tmp;
+#else
+      v = y + y*u;
+#endif
+    }
+
+  if (xneg) return -v;
+  else return v;
+}
+
+weak_alias (__asin, asin)
diff --git a/src/asinf.c b/src/asinf.c
new file mode 100644
index 0000000..4b42b01
--- /dev/null
+++ b/src/asinf.c
@@ -0,0 +1,190 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#define USE_VALF_WITH_FLAGS
+#define USE_NANF_WITH_FLAGS
+#define USE_HANDLE_ERRORF
+#include "../inc/libm_inlines_amd.h"
+#undef USE_NANF_WITH_FLAGS
+#undef USE_VALF_WITH_FLAGS
+#undef USE_HANDLE_ERRORF
+
+#include "../inc/libm_errno_amd.h"
+
+#ifndef WINDOWS
+/* Deal with errno for out-of-range argument */
+static inline float retval_errno_edom(float x)
+{
+  struct exception exc;
+  exc.arg1 = (double)x;
+  exc.arg2 = (double)x;
+  exc.type = DOMAIN;
+  exc.name = (char *)"asinf";
+  if (_LIB_VERSION == _SVID_)
+    exc.retval = HUGE;
+  else
+    exc.retval = nanf_with_flags(AMD_F_INVALID);
+  if (_LIB_VERSION == _POSIX_)
+    __set_errno(EDOM);
+  else if (!matherr(&exc))
+    {
+      if(_LIB_VERSION == _SVID_)
+        (void)fputs("asinf: DOMAIN error\n", stderr);
+    __set_errno(EDOM);
+    }
+  return exc.retval;
+}
+#endif
+
+#ifdef WINDOWS
+#pragma function(asinf)
+#endif
+
+float FN_PROTOTYPE(asinf)(float x)
+{
+  /* Computes arcsin(x).
+     The argument is first reduced by noting that arcsin(x)
+     is invalid for abs(x) > 1 and arcsin(-x) = -arcsin(x).
+     For denormal and small arguments arcsin(x) = x to machine
+     accuracy. Remaining argument ranges are handled as follows.
+     For abs(x) <= 0.5 use
+     arcsin(x) = x + x^3*R(x^2)
+     where R(x^2) is a rational minimax approximation to
+     (arcsin(x) - x)/x^3.
+     For abs(x) > 0.5 exploit the identity:
+      arcsin(x) = pi/2 - 2*arcsin(sqrt(1-x)/2)
+     together with the above rational approximation, and
+     reconstruct the terms carefully.
+    */
+
+  /* Some constants and split constants. */
+
+  static const float
+    piby2_tail  = 7.5497894159e-08F, /* 0x33a22168 */
+    hpiby2_head = 7.8539812565e-01F, /* 0x3f490fda */
+    piby2       = 1.5707963705e+00F; /* 0x3fc90fdb */
+  float u, v, y, s = 0.0F, r;
+  int xexp, xnan, transform = 0;
+
+  unsigned int ux, aux, xneg;
+  GET_BITS_SP32(x, ux);
+  aux = ux & ~SIGNBIT_SP32;
+  xneg = (ux & SIGNBIT_SP32);
+  xnan = (aux > PINFBITPATT_SP32);
+  xexp = (int)((ux & EXPBITS_SP32) >> EXPSHIFTBITS_SP32) - EXPBIAS_SP32;
+
+  /* Special cases */
+
+  if (xnan)
+    {
+#ifdef WINDOWS
+      return handle_errorf("asinf", ux|0x00400000, _DOMAIN, 0,
+                           EDOM, x, 0.0F);
+#else
+      return x + x; /* With invalid if it's a signalling NaN */
+#endif
+    }
+  else if (xexp < -14)
+    /* y small enough that arcsin(x) = x */
+    return valf_with_flags(x, AMD_F_INEXACT);
+  else if (xexp >= 0)
+    {
+      /* abs(x) >= 1.0 */
+      if (x == 1.0F)
+        return valf_with_flags(piby2, AMD_F_INEXACT);
+      else if (x == -1.0F)
+        return valf_with_flags(-piby2, AMD_F_INEXACT);
+      else
+#ifdef WINDOWS
+        return handle_errorf("asinf", INDEFBITPATT_SP32, _DOMAIN,
+                             AMD_F_INVALID, EDOM, x, 0.0F);
+#else
+        return retval_errno_edom(x);
+#endif
+    }
+
+  if (xneg) y = -x;
+  else y = x;
+
+  transform = (xexp >= -1); /* abs(x) >= 0.5 */
+
+  if (transform)
+    { /* Transform y into the range [0,0.5) */
+      r = 0.5F*(1.0F - y);
+#ifdef WINDOWS
+      /* VC++ intrinsic call */
+      _mm_store_ss(&s, _mm_sqrt_ss(_mm_load_ss(&r)));
+#else
+      /* Hammer sqrt instruction */
+      asm volatile ("sqrtss %1, %0" : "=x" (s) : "x" (r));
+#endif
+      y = s;
+    }
+  else
+    r = y*y;
+
+  /* Use a rational approximation for [0.0, 0.5] */
+
+  u=r*(0.184161606965100694821398249421F +
+       (-0.0565298683201845211985026327361F +
+	(-0.0133819288943925804214011424456F -
+	 0.00396137437848476485201154797087F*r)*r)*r)/
+    (1.10496961524520294485512696706F -
+     0.836411276854206731913362287293F*r);
+
+  if (transform)
+    {
+      /* Reconstruct asin carefully in transformed region */
+      float c, s1, p, q;
+      unsigned int us;
+      GET_BITS_SP32(s, us);
+      PUT_BITS_SP32(0xffff0000 & us, s1);
+      c = (r-s1*s1)/(s+s1);
+      p = 2.0F*s*u - (piby2_tail-2.0F*c);
+      q = hpiby2_head - 2.0F*s1;
+      v = hpiby2_head - (p-q);
+    }
+  else
+    {
+#ifdef WINDOWS
+      /* Use a temporary variable to prevent VC++ rearranging
+            y + y*u
+         into
+            y * (1 + u)
+         and getting an incorrectly rounded result */
+      float tmp;
+      tmp = y * u;
+      v = y + tmp;
+#else
+      v = y + y*u;
+#endif
+    }
+
+  if (xneg) return -v;
+  else return v;
+}
+
+weak_alias (__asinf, asinf)
diff --git a/src/asinh.c b/src/asinh.c
new file mode 100644
index 0000000..7ecde9c
--- /dev/null
+++ b/src/asinh.c
@@ -0,0 +1,322 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#define USE_HANDLE_ERROR
+#define USE_LOG_KERNEL_AMD
+#define USE_VAL_WITH_FLAGS
+#include "../inc/libm_inlines_amd.h"
+#undef USE_HANDLE_ERROR
+#undef USE_LOG_KERNEL_AMD
+#undef VAL_WITH_FLAGS
+
+#undef _FUNCNAME
+#define _FUNCNAME "asinh"
+double FN_PROTOTYPE(asinh)(double x)
+{
+
+  unsigned long long ux, ax, xneg;
+  double absx, r, rarg, t, r1, r2, poly, s, v1, v2;
+  int xexp;
+
+  static const unsigned long long
+    rteps = 0x3e46a09e667f3bcd,    /* sqrt(eps) = 1.05367121277235086670e-08 */
+    recrteps = 0x4196a09e667f3bcd; /* 1/rteps = 9.49062656242515593767e+07 */
+
+  /* log2_lead and log2_tail sum to an extra-precise version
+     of log(2) */
+  static const double
+    log2_lead = 6.93147122859954833984e-01,  /* 0x3fe62e42e0000000 */
+    log2_tail = 5.76999904754328540596e-08;  /* 0x3e6efa39ef35793c */
+
+
+  GET_BITS_DP64(x, ux);
+  ax = ux & ~SIGNBIT_DP64;
+  xneg = ux & SIGNBIT_DP64;
+  PUT_BITS_DP64(ax, absx);
+
+  if ((ux & EXPBITS_DP64) == EXPBITS_DP64)
+    {
+      /* x is either NaN or infinity */
+      if (ux & MANTBITS_DP64)
+        {
+          /* x is NaN */
+#ifdef WINDOWS
+          return handle_error(_FUNCNAME, ux|0x0008000000000000, _DOMAIN,
+                              AMD_F_INVALID, EDOM, x, 0.0);
+#else
+          return x + x; /* Raise invalid if it is a signalling NaN */
+#endif
+        }
+      else
+        {
+          /* x is infinity. Return the same infinity. */
+#ifdef WINDOWS
+          if (ux & SIGNBIT_DP64)
+            return handle_error(_FUNCNAME, NINFBITPATT_DP64, _DOMAIN,
+                                AMD_F_INVALID, EDOM, x, 0.0);
+          else
+            return handle_error(_FUNCNAME, PINFBITPATT_DP64, _DOMAIN,
+                                AMD_F_INVALID, EDOM, x, 0.0);
+#else
+          return x;
+#endif
+        }
+    }
+  else if (ax < rteps) /* abs(x) < sqrt(epsilon) */
+    {
+      if (ax == 0x0000000000000000)
+        {
+          /* x is +/-zero. Return the same zero. */
+          return x;
+        }
+      else
+        {
+          /* Tiny arguments approximated by asinh(x) = x
+             - avoid slow operations on denormalized numbers */
+          return val_with_flags(x,AMD_F_INEXACT);
+        }
+    }
+
+
+  if (ax <= 0x3ff0000000000000) /* abs(x) <= 1.0 */
+    {
+      /* Arguments less than 1.0 in magnitude are
+         approximated by [4,4] or [5,4] minimax polynomials
+         fitted to asinh series 4.6.31 (x < 1) from Abramowitz and Stegun
+      */
+      t = x*x;
+      if (ax < 0x3fd0000000000000)
+        {
+          /* [4,4] for 0 < abs(x) < 0.25 */
+          poly =
+            (-0.12845379283524906084997e0 +
+             (-0.21060688498409799700819e0 +
+              (-0.10188951822578188309186e0 +
+               (-0.13891765817243625541799e-1 -
+                0.10324604871728082428024e-3 * t) * t) * t) * t) /
+            (0.77072275701149440164511e0 +
+             (0.16104665505597338100747e1 +
+              (0.11296034614816689554875e1 +
+               (0.30079351943799465092429e0 +
+                0.235224464765951442265117e-1 * t) * t) * t) * t);
+        }
+      else if (ax < 0x3fe0000000000000)
+        {
+          /* [4,4] for 0.25 <= abs(x) < 0.5 */
+          poly =
+            (-0.12186605129448852495563e0 +
+             (-0.19777978436593069928318e0 +
+              (-0.94379072395062374824320e-1 +
+               (-0.12620141363821680162036e-1 -
+                0.903396794842691998748349e-4 * t) * t) * t) * t) /
+            (0.73119630776696495279434e0 +
+             (0.15157170446881616648338e1 +
+              (0.10524909506981282725413e1 +
+               (0.27663713103600182193817e0 +
+                0.21263492900663656707646e-1 * t) * t) * t) * t);
+        }
+      else if (ax < 0x3fe8000000000000)
+        {
+          /* [4,4] for 0.5 <= abs(x) < 0.75 */
+          poly =
+            (-0.81210026327726247622500e-1 +
+             (-0.12327355080668808750232e0 +
+              (-0.53704925162784720405664e-1 +
+               (-0.63106739048128554465450e-2 -
+                0.35326896180771371053534e-4 * t) * t) * t) * t) /
+            (0.48726015805581794231182e0 +
+             (0.95890837357081041150936e0 +
+              (0.62322223426940387752480e0 +
+               (0.15028684818508081155141e0 +
+                0.10302171620320141529445e-1 * t) * t) * t) * t);
+        }
+      else
+        {
+          /* [5,4] for 0.75 <= abs(x) <= 1.0 */
+          poly =
+            (-0.4638179204422665073e-1 +
+             (-0.7162729496035415183e-1 +
+              (-0.3247795155696775148e-1 +
+               (-0.4225785421291932164e-2 +
+                (-0.3808984717603160127e-4 +
+                 0.8023464184964125826e-6 * t) * t) * t) * t) * t) /
+            (0.2782907534642231184e0 +
+             (0.5549945896829343308e0 +
+              (0.3700732511330698879e0 +
+               (0.9395783438240780722e-1 +
+                0.7200057974217143034e-2 * t) * t) * t) * t);
+        }
+      return x + x*t*poly;
+    }
+  else if (ax < 0x4040000000000000)
+    {
+      /* 1.0 <= abs(x) <= 32.0 */
+      /* Arguments in this region are approximated by various
+         minimax polynomials fitted to asinh series 4.6.31
+         in Abramowitz and Stegun.
+      */
+      t = x*x;
+      if (ax >= 0x4020000000000000)
+        {
+          /* [3,3] for 8.0 <= abs(x) <= 32.0 */
+          poly =
+            (-0.538003743384069117e-10 +
+             (-0.273698654196756169e-9 +
+              (-0.268129826956403568e-9 -
+               0.804163374628432850e-29 * t) * t) * t) /
+            (0.238083376363471960e-9 +
+             (0.203579344621125934e-8 +
+              (0.450836980450693209e-8 +
+               0.286005148753497156e-8 * t) * t) * t);
+        }
+      else if (ax >= 0x4010000000000000)
+        {
+          /* [4,3] for 4.0 <= abs(x) <= 8.0 */
+          poly =
+            (-0.178284193496441400e-6 +
+             (-0.928734186616614974e-6 +
+              (-0.923318925566302615e-6 +
+               (-0.776417026702577552e-19 +
+                0.290845644810826014e-21 * t) * t) * t) * t) /
+            (0.786694697277890964e-6 +
+             (0.685435665630965488e-5 +
+              (0.153780175436788329e-4 +
+               0.984873520613417917e-5 * t) * t) * t);
+
+        }
+      else if (ax >= 0x4000000000000000)
+        {
+          /* [5,4] for 2.0 <= abs(x) <= 4.0 */
+          poly =
+            (-0.209689451648100728e-6 +
+             (-0.219252358028695992e-5 +
+              (-0.551641756327550939e-5 +
+               (-0.382300259826830258e-5 +
+                (-0.421182121910667329e-17 +
+                 0.492236019998237684e-19 * t) * t) * t) * t) * t) /
+            (0.889178444424237735e-6 +
+             (0.131152171690011152e-4 +
+              (0.537955850185616847e-4 +
+               (0.814966175170941864e-4 +
+                0.407786943832260752e-4 * t) * t) * t) * t);
+        }
+      else if (ax >= 0x3ff8000000000000)
+        {
+          /* [5,4] for 1.5 <= abs(x) <= 2.0 */
+          poly =
+            (-0.195436610112717345e-4 +
+             (-0.233315515113382977e-3 +
+              (-0.645380957611087587e-3 +
+               (-0.478948863920281252e-3 +
+                (-0.805234112224091742e-12 +
+                 0.246428598194879283e-13 * t) * t) * t) * t) * t) /
+            (0.822166621698664729e-4 +
+             (0.135346265620413852e-2 +
+              (0.602739242861830658e-2 +
+               (0.972227795510722956e-2 +
+                0.510878800983771167e-2 * t) * t) * t) * t);
+        }
+      else
+        {
+          /* [5,5] for 1.0 <= abs(x) <= 1.5 */
+          poly =
+            (-0.121224194072430701e-4 +
+             (-0.273145455834305218e-3 +
+              (-0.152866982560895737e-2 +
+               (-0.292231744584913045e-2 +
+                (-0.174670900236060220e-2 -
+                 0.891754209521081538e-12 * t) * t) * t) * t) * t) /
+            (0.499426632161317606e-4 +
+             (0.139591210395547054e-2 +
+              (0.107665231109108629e-1 +
+               (0.325809818749873406e-1 +
+                (0.415222526655158363e-1 +
+                 0.186315628774716763e-1 * t) * t) * t) * t) * t);
+        }
+      log_kernel_amd64(absx, ax, &xexp, &r1, &r2);
+      r1 = ((xexp+1) * log2_lead + r1);
+      r2 = ((xexp+1) * log2_tail + r2);
+      /* Now (r1,r2) sum to log(2x). Add the term
+         1/(2.2.x^2) = 0.25/t, and add poly/t, carefully
+         to maintain precision. (Note that we add poly/t
+         rather than poly because of the *x factor used
+         when generating the minimax polynomial) */
+      v2 = (poly+0.25)/t;
+      r = v2 + r1;
+      s = ((r1 - r) + v2) + r2;
+      v1 = r + s;
+      v2 = (r - v1) + s;
+      r = v1 + v2;
+      if (xneg)
+        return -r;
+      else
+        return r;
+    }
+  else
+    {
+      /* abs(x) > 32.0 */
+      if (ax > recrteps)
+        {
+          /* Arguments greater than 1/sqrt(epsilon) in magnitude are
+             approximated by asinh(x) = ln(2) + ln(abs(x)), with sign of x */
+          /* log_kernel_amd(x) returns xexp, r1, r2 such that
+             log(x) = xexp*log(2) + r1 + r2 */
+          log_kernel_amd64(absx, ax, &xexp, &r1, &r2);
+          /* Add (xexp+1) * log(2) to z1,z2 to get the result asinh(x).
+             The computed r1 is not subject to rounding error because
+             (xexp+1) has at most 10 significant bits, log(2) has 24 significant
+             bits, and r1 has up to 24 bits; and the exponents of r1
+             and r2 differ by at most 6. */
+          r1 = ((xexp+1) * log2_lead + r1);
+          r2 = ((xexp+1) * log2_tail + r2);
+          if (xneg)
+            return -(r1 + r2);
+          else
+            return r1 + r2;
+        }
+      else
+        {
+          rarg = absx*absx+1.0;
+          /* Arguments such that 32.0 <= abs(x) <= 1/sqrt(epsilon) are
+             approximated by
+               asinh(x) = ln(abs(x) + sqrt(x*x+1))
+             with the sign of x (see Abramowitz and Stegun 4.6.20) */
+          /* Use assembly instruction to compute r = sqrt(rarg); */
+          ASMSQRT(rarg,r);
+          r += absx;
+          GET_BITS_DP64(r, ax);
+          log_kernel_amd64(r, ax, &xexp, &r1, &r2);
+          r1 = (xexp * log2_lead + r1);
+          r2 = (xexp * log2_tail + r2);
+          if (xneg)
+            return -(r1 + r2);
+          else
+            return r1 + r2;
+        }
+    }
+}
+
+weak_alias (__asinh, asinh)
diff --git a/src/asinhf.c b/src/asinhf.c
new file mode 100644
index 0000000..f5d3bf9
--- /dev/null
+++ b/src/asinhf.c
@@ -0,0 +1,164 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#include <stdio.h>
+
+#define USE_HANDLE_ERRORF
+#define USE_VALF_WITH_FLAGS
+#include "../inc/libm_inlines_amd.h"
+#undef USE_HANDLE_ERRORF
+#undef VALF_WITH_FLAGS
+
+#undef _FUNCNAME
+#define _FUNCNAME "asinhf"
+float FN_PROTOTYPE(asinhf)(float x)
+{
+
+  double dx;
+  unsigned int ux, ax, xneg;
+  double absx, r, rarg, t, poly;
+
+  static const unsigned int
+    rteps = 0x39800000,    /* sqrt(eps) = 2.44140625000000000000e-04 */
+    recrteps = 0x46000000; /* 1/rteps = 4.09600000000000000000e+03 */
+
+  static const double
+    log2 = 6.93147180559945286227e-01;  /* 0x3fe62e42fefa39ef */
+
+  GET_BITS_SP32(x, ux);
+  ax = ux & ~SIGNBIT_SP32;
+  xneg = ux & SIGNBIT_SP32;
+
+  if ((ux & EXPBITS_SP32) == EXPBITS_SP32)
+    {
+      /* x is either NaN or infinity */
+      if (ux & MANTBITS_SP32)
+        {
+          /* x is NaN */
+#ifdef WINDOWS
+          return handle_errorf(_FUNCNAME, ux|0x00400000, _DOMAIN,
+                               0, EDOM, x, 0.0F);
+#else
+          return x + x; /* Raise invalid if it is a signalling NaN */
+#endif
+        }
+      else
+        {
+          /* x is infinity. Return the same infinity. */
+#ifdef WINDOWS
+          if (ux & SIGNBIT_SP32)
+            return handle_errorf(_FUNCNAME, NINFBITPATT_SP32, _DOMAIN,
+                                 AMD_F_INVALID, EDOM, x, 0.0F);
+          else
+            return handle_errorf(_FUNCNAME, PINFBITPATT_SP32, _DOMAIN,
+                                 AMD_F_INVALID, EDOM, x, 0.0F);
+#else
+          return x;
+#endif
+        }
+    }
+  else if (ax < rteps) /* abs(x) < sqrt(epsilon) */
+    {
+      if (ax == 0x00000000)
+        {
+          /* x is +/-zero. Return the same zero. */
+          return x;
+        }
+      else
+        {
+          /* Tiny arguments approximated by asinhf(x) = x
+             - avoid slow operations on denormalized numbers */
+          return valf_with_flags(x,AMD_F_INEXACT);
+        }
+    }
+
+  dx = x;
+  if (xneg)
+    absx = -dx;
+  else
+    absx = dx;
+
+  if (ax <= 0x40800000) /* abs(x) <= 4.0 */
+    {
+      /* Arguments less than 4.0 in magnitude are
+         approximated by [4,4] minimax polynomials
+      */
+      t = dx*dx;
+      if (ax <= 0x40000000) /* abs(x) <= 2 */
+        poly =
+          (-0.1152965835871758072e-1 +
+          (-0.1480204186473758321e-1 +
+          (-0.5063201055468483248e-2 +
+          (-0.4162727710583425360e-3 -
+            0.1177198915954942694e-5 * t) * t) * t) * t) /
+           (0.6917795026025976739e-1 +
+           (0.1199423176003939087e+0 +
+           (0.6582362487198468066e-1 +
+           (0.1260024978680227945e-1 +
+            0.6284381367285534560e-3 * t) * t) * t) * t);
+      else
+        poly =
+           (-0.185462290695578589e-2 +
+           (-0.113672533502734019e-2 +
+           (-0.142208387300570402e-3 +
+           (-0.339546014993079977e-5 -
+             0.151054665394480990e-8 * t) * t) * t) * t) /
+            (0.111486158580024771e-1 +
+            (0.117782437980439561e-1 +
+            (0.325903773532674833e-2 +
+            (0.255902049924065424e-3 +
+             0.434150786948890837e-5 * t) * t) * t) * t);
+      return (float)(dx + dx*t*poly);
+    }
+  else
+    {
+      /* abs(x) > 4.0 */
+      if (ax > recrteps)
+        {
+          /* Arguments greater than 1/sqrt(epsilon) in magnitude are
+             approximated by asinhf(x) = ln(2) + ln(abs(x)), with sign of x */
+          r = FN_PROTOTYPE(log)(absx) + log2;
+        }
+      else
+        {
+          rarg = absx*absx+1.0;
+          /* Arguments such that 4.0 <= abs(x) <= 1/sqrt(epsilon) are
+             approximated by
+               asinhf(x) = ln(abs(x) + sqrt(x*x+1))
+             with the sign of x (see Abramowitz and Stegun 4.6.20) */
+          /* Use assembly instruction to compute r = sqrt(rarg); */
+          ASMSQRT(rarg,r);
+          r += absx;
+          r = FN_PROTOTYPE(log)(r);
+        }
+      if (xneg)
+        return (float)(-r);
+      else
+        return (float)r;
+    }
+}
+
+weak_alias (__asinhf, asinhf)
diff --git a/src/atan.c b/src/atan.c
new file mode 100644
index 0000000..3b99df9
--- /dev/null
+++ b/src/atan.c
@@ -0,0 +1,171 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#define USE_VAL_WITH_FLAGS
+#define USE_NAN_WITH_FLAGS
+#define USE_HANDLE_ERROR
+#include "../inc/libm_inlines_amd.h"
+#undef USE_VAL_WITH_FLAGS
+#undef USE_NAN_WITH_FLAGS
+#undef USE_HANDLE_ERROR
+
+#include "../inc/libm_errno_amd.h"
+
+#ifndef WINDOWS
+/* Deal with errno for out-of-range argument */
+static inline double retval_errno_edom(double x)
+{
+  struct exception exc;
+  exc.arg1 = x;
+  exc.arg2 = x;
+  exc.name = (char *)"atan";
+  exc.type = DOMAIN;
+  if (_LIB_VERSION == _SVID_)
+    exc.retval = HUGE;
+  else
+    exc.retval = nan_with_flags(AMD_F_INVALID);
+  if (_LIB_VERSION == _POSIX_)
+    __set_errno(EDOM);
+  else if (!matherr(&exc))
+    {
+      if(_LIB_VERSION == _SVID_)
+        (void)fputs("atan: DOMAIN error\n", stderr);
+    __set_errno(EDOM);
+    }
+  return exc.retval;
+}
+#endif
+
+#ifdef WINDOWS
+#pragma function(atan)
+#endif
+
+double FN_PROTOTYPE(atan)(double x)
+{
+
+  /* Some constants and split constants. */
+
+  static double piby2 = 1.5707963267948966e+00; /* 0x3ff921fb54442d18 */
+  double chi, clo, v, s, q, z;
+
+  /* Find properties of argument x. */
+
+  unsigned long long ux, aux, xneg;
+  GET_BITS_DP64(x, ux);
+  aux = ux & ~SIGNBIT_DP64;
+  xneg = (ux != aux);
+
+  if (xneg) v = -x;
+  else v = x;
+
+  /* Argument reduction to range [-7/16,7/16] */
+
+  if (aux < 0x3e50000000000000) /* v < 2.0^(-26) */
+    {
+      /* x is a good approximation to atan(x) and avoids working on
+         intermediate denormal numbers */
+      if (aux == 0x0000000000000000)
+        return x;
+      else
+        return val_with_flags(x, AMD_F_INEXACT);
+    }
+  else if (aux > 0x4003800000000000) /* v > 39./16. */
+    {
+
+      if (aux > PINFBITPATT_DP64)
+        {
+          /* x is NaN */
+#ifdef WINDOWS
+          return handle_error("atan", ux|0x0008000000000000, _DOMAIN, 0,
+                              EDOM, x, 0.0);
+#else
+          return x + x; /* Raise invalid if it's a signalling NaN */
+#endif
+        }
+      else if (aux > 0x4370000000000000)
+	{ /* abs(x) > 2^56 => arctan(1/x) is
+	     insignificant compared to piby2 */
+	  if (xneg)
+            return val_with_flags(-piby2, AMD_F_INEXACT);
+	  else
+            return val_with_flags(piby2, AMD_F_INEXACT);
+	}
+
+      x = -1.0/v;
+      /* (chi + clo) = arctan(infinity) */
+      chi = 1.57079632679489655800e+00; /* 0x3ff921fb54442d18 */
+      clo = 6.12323399573676480327e-17; /* 0x3c91a62633145c06 */
+    }
+  else if (aux > 0x3ff3000000000000) /* 39./16. > v > 19./16. */
+    {
+      x = (v-1.5)/(1.0+1.5*v);
+      /* (chi + clo) = arctan(1.5) */
+      chi = 9.82793723247329054082e-01; /* 0x3fef730bd281f69b */
+      clo = 1.39033110312309953701e-17; /* 0x3c7007887af0cbbc */
+    }
+  else if (aux > 0x3fe6000000000000) /* 19./16. > v > 11./16. */
+    {
+      x = (v-1.0)/(1.0+v);
+      /* (chi + clo) = arctan(1.) */
+      chi = 7.85398163397448278999e-01; /* 0x3fe921fb54442d18 */
+      clo = 3.06161699786838240164e-17; /* 0x3c81a62633145c06 */
+    }
+  else if (aux > 0x3fdc000000000000) /* 11./16. > v > 7./16. */
+    {
+      x = (2.0*v-1.0)/(2.0+v);
+      /* (chi + clo) = arctan(0.5) */
+      chi = 4.63647609000806093515e-01; /* 0x3fddac670561bb4f */
+      clo = 2.26987774529616809294e-17; /* 0x3c7a2b7f222f65e0 */
+    }
+  else  /* v < 7./16. */
+    {
+      x = v;
+      chi = 0.0;
+      clo = 0.0;
+    }
+
+  /* Core approximation: Remez(4,4) on [-7/16,7/16] */
+
+  s = x*x;
+  q = x*s*
+       (0.268297920532545909e0 +
+	(0.447677206805497472e0 +
+	 (0.220638780716667420e0 +
+	  (0.304455919504853031e-1 +
+	    0.142316903342317766e-3*s)*s)*s)*s)/
+       (0.804893761597637733e0 +
+	(0.182596787737507063e1 +
+	 (0.141254259931958921e1 +
+	  (0.424602594203847109e0 +
+	    0.389525873944742195e-1*s)*s)*s)*s);
+
+  z = chi - ((q - clo) - x);
+
+  if (xneg) z = -z;
+  return z;
+}
+
+weak_alias (__atan, atan)
diff --git a/src/atan2.c b/src/atan2.c
new file mode 100644
index 0000000..6531ee4
--- /dev/null
+++ b/src/atan2.c
@@ -0,0 +1,785 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#define USE_VAL_WITH_FLAGS
+#define USE_NAN_WITH_FLAGS
+#define USE_SCALEDOUBLE_1
+#define USE_SCALEDOUBLE_2
+#define USE_SCALEUPDOUBLE1024
+#define USE_SCALEDOWNDOUBLE
+#define USE_HANDLE_ERROR
+#include "../inc/libm_inlines_amd.h"
+#undef USE_VAL_WITH_FLAGS
+#undef USE_NAN_WITH_FLAGS
+#undef USE_SCALEDOUBLE_1
+#undef USE_SCALEDOUBLE_2
+#undef USE_SCALEUPDOUBLE1024
+#undef USE_SCALEDOWNDOUBLE
+#undef USE_HANDLE_ERROR
+
+#include "../inc/libm_errno_amd.h"
+
+#ifndef WINDOWS
+/* Deal with errno for out-of-range arguments
+   (only used when _LIB_VERSION is _SVID_) */
+static inline double retval_errno_edom(double x, double y)
+{
+  struct exception exc;
+  exc.arg1 = x;
+  exc.arg2 = y;
+  exc.name = (char *)"atan2";
+  exc.type = DOMAIN;
+  exc.retval = HUGE;
+  if (!matherr(&exc))
+    {
+      (void)fputs("atan2: DOMAIN error\n", stderr);
+      __set_errno(EDOM);
+    }
+  return exc.retval;
+}
+#endif
+
+#ifdef WINDOWS
+#pragma function(atan2)
+#endif
+
+double FN_PROTOTYPE(atan2)(double y, double x)
+{
+  /* Arrays atan_jby256_lead and atan_jby256_tail contain
+     leading and trailing parts respectively of precomputed
+     values of atan(j/256), for j = 16, 17, ..., 256.
+     atan_jby256_lead contains the first 21 bits of precision,
+     and atan_jby256_tail contains a further 53 bits precision. */
+
+  static const double atan_jby256_lead[  241] = {
+    6.24187886714935302734e-02,  /* 0x3faff55b00000000 */
+    6.63088560104370117188e-02,  /* 0x3fb0f99e00000000 */
+    7.01969265937805175781e-02,  /* 0x3fb1f86d00000000 */
+    7.40829110145568847656e-02,  /* 0x3fb2f71900000000 */
+    7.79666304588317871094e-02,  /* 0x3fb3f59f00000000 */
+    8.18479657173156738281e-02,  /* 0x3fb4f3fd00000000 */
+    8.57268571853637695312e-02,  /* 0x3fb5f23200000000 */
+    8.96031260490417480469e-02,  /* 0x3fb6f03b00000000 */
+    9.34767723083496093750e-02,  /* 0x3fb7ee1800000000 */
+    9.73475575447082519531e-02,  /* 0x3fb8ebc500000000 */
+    1.01215422153472900391e-01,  /* 0x3fb9e94100000000 */
+    1.05080246925354003906e-01,  /* 0x3fbae68a00000000 */
+    1.08941912651062011719e-01,  /* 0x3fbbe39e00000000 */
+    1.12800359725952148438e-01,  /* 0x3fbce07c00000000 */
+    1.16655409336090087891e-01,  /* 0x3fbddd2100000000 */
+    1.20507001876831054688e-01,  /* 0x3fbed98c00000000 */
+    1.24354958534240722656e-01,  /* 0x3fbfd5ba00000000 */
+    1.28199219703674316406e-01,  /* 0x3fc068d500000000 */
+    1.32039666175842285156e-01,  /* 0x3fc0e6ad00000000 */
+    1.35876297950744628906e-01,  /* 0x3fc1646500000000 */
+    1.39708757400512695312e-01,  /* 0x3fc1e1fa00000000 */
+    1.43537282943725585938e-01,  /* 0x3fc25f6e00000000 */
+    1.47361397743225097656e-01,  /* 0x3fc2dcbd00000000 */
+    1.51181221008300781250e-01,  /* 0x3fc359e800000000 */
+    1.54996633529663085938e-01,  /* 0x3fc3d6ee00000000 */
+    1.58807516098022460938e-01,  /* 0x3fc453ce00000000 */
+    1.62613749504089355469e-01,  /* 0x3fc4d08700000000 */
+    1.66415214538574218750e-01,  /* 0x3fc54d1800000000 */
+    1.70211911201477050781e-01,  /* 0x3fc5c98100000000 */
+    1.74003481864929199219e-01,  /* 0x3fc645bf00000000 */
+    1.77790164947509765625e-01,  /* 0x3fc6c1d400000000 */
+    1.81571602821350097656e-01,  /* 0x3fc73dbd00000000 */
+    1.85347914695739746094e-01,  /* 0x3fc7b97b00000000 */
+    1.89118742942810058594e-01,  /* 0x3fc8350b00000000 */
+    1.92884206771850585938e-01,  /* 0x3fc8b06e00000000 */
+    1.96644186973571777344e-01,  /* 0x3fc92ba300000000 */
+    2.00398445129394531250e-01,  /* 0x3fc9a6a800000000 */
+    2.04147100448608398438e-01,  /* 0x3fca217e00000000 */
+    2.07889914512634277344e-01,  /* 0x3fca9c2300000000 */
+    2.11626768112182617188e-01,  /* 0x3fcb169600000000 */
+    2.15357661247253417969e-01,  /* 0x3fcb90d700000000 */
+    2.19082474708557128906e-01,  /* 0x3fcc0ae500000000 */
+    2.22801089286804199219e-01,  /* 0x3fcc84bf00000000 */
+    2.26513504981994628906e-01,  /* 0x3fccfe6500000000 */
+    2.30219483375549316406e-01,  /* 0x3fcd77d500000000 */
+    2.33919143676757812500e-01,  /* 0x3fcdf11000000000 */
+    2.37612247467041015625e-01,  /* 0x3fce6a1400000000 */
+    2.41298794746398925781e-01,  /* 0x3fcee2e100000000 */
+    2.44978547096252441406e-01,  /* 0x3fcf5b7500000000 */
+    2.48651623725891113281e-01,  /* 0x3fcfd3d100000000 */
+    2.52317905426025390625e-01,  /* 0x3fd025fa00000000 */
+    2.55977153778076171875e-01,  /* 0x3fd061ee00000000 */
+    2.59629487991333007812e-01,  /* 0x3fd09dc500000000 */
+    2.63274669647216796875e-01,  /* 0x3fd0d97e00000000 */
+    2.66912937164306640625e-01,  /* 0x3fd1151a00000000 */
+    2.70543813705444335938e-01,  /* 0x3fd1509700000000 */
+    2.74167299270629882812e-01,  /* 0x3fd18bf500000000 */
+    2.77783632278442382812e-01,  /* 0x3fd1c73500000000 */
+    2.81392335891723632812e-01,  /* 0x3fd2025500000000 */
+    2.84993648529052734375e-01,  /* 0x3fd23d5600000000 */
+    2.88587331771850585938e-01,  /* 0x3fd2783700000000 */
+    2.92173147201538085938e-01,  /* 0x3fd2b2f700000000 */
+    2.95751571655273437500e-01,  /* 0x3fd2ed9800000000 */
+    2.99322128295898437500e-01,  /* 0x3fd3281800000000 */
+    3.02884817123413085938e-01,  /* 0x3fd3627700000000 */
+    3.06439399719238281250e-01,  /* 0x3fd39cb400000000 */
+    3.09986352920532226562e-01,  /* 0x3fd3d6d100000000 */
+    3.13524961471557617188e-01,  /* 0x3fd410cb00000000 */
+    3.17055702209472656250e-01,  /* 0x3fd44aa400000000 */
+    3.20578098297119140625e-01,  /* 0x3fd4845a00000000 */
+    3.24092388153076171875e-01,  /* 0x3fd4bdee00000000 */
+    3.27598333358764648438e-01,  /* 0x3fd4f75f00000000 */
+    3.31095933914184570312e-01,  /* 0x3fd530ad00000000 */
+    3.34585189819335937500e-01,  /* 0x3fd569d800000000 */
+    3.38066101074218750000e-01,  /* 0x3fd5a2e000000000 */
+    3.41538190841674804688e-01,  /* 0x3fd5dbc300000000 */
+    3.45002174377441406250e-01,  /* 0x3fd6148400000000 */
+    3.48457098007202148438e-01,  /* 0x3fd64d1f00000000 */
+    3.51903676986694335938e-01,  /* 0x3fd6859700000000 */
+    3.55341434478759765625e-01,  /* 0x3fd6bdea00000000 */
+    3.58770608901977539062e-01,  /* 0x3fd6f61900000000 */
+    3.62190723419189453125e-01,  /* 0x3fd72e2200000000 */
+    3.65602254867553710938e-01,  /* 0x3fd7660700000000 */
+    3.69004726409912109375e-01,  /* 0x3fd79dc600000000 */
+    3.72398376464843750000e-01,  /* 0x3fd7d56000000000 */
+    3.75782966613769531250e-01,  /* 0x3fd80cd400000000 */
+    3.79158496856689453125e-01,  /* 0x3fd8442200000000 */
+    3.82525205612182617188e-01,  /* 0x3fd87b4b00000000 */
+    3.85882616043090820312e-01,  /* 0x3fd8b24d00000000 */
+    3.89230966567993164062e-01,  /* 0x3fd8e92900000000 */
+    3.92570018768310546875e-01,  /* 0x3fd91fde00000000 */
+    3.95900011062622070312e-01,  /* 0x3fd9566d00000000 */
+    3.99220705032348632812e-01,  /* 0x3fd98cd500000000 */
+    4.02532100677490234375e-01,  /* 0x3fd9c31600000000 */
+    4.05834197998046875000e-01,  /* 0x3fd9f93000000000 */
+    4.09126996994018554688e-01,  /* 0x3fda2f2300000000 */
+    4.12410259246826171875e-01,  /* 0x3fda64ee00000000 */
+    4.15684223175048828125e-01,  /* 0x3fda9a9200000000 */
+    4.18948888778686523438e-01,  /* 0x3fdad00f00000000 */
+    4.22204017639160156250e-01,  /* 0x3fdb056400000000 */
+    4.25449609756469726562e-01,  /* 0x3fdb3a9100000000 */
+    4.28685665130615234375e-01,  /* 0x3fdb6f9600000000 */
+    4.31912183761596679688e-01,  /* 0x3fdba47300000000 */
+    4.35129165649414062500e-01,  /* 0x3fdbd92800000000 */
+    4.38336372375488281250e-01,  /* 0x3fdc0db400000000 */
+    4.41534280776977539062e-01,  /* 0x3fdc421900000000 */
+    4.44722414016723632812e-01,  /* 0x3fdc765500000000 */
+    4.47900772094726562500e-01,  /* 0x3fdcaa6800000000 */
+    4.51069593429565429688e-01,  /* 0x3fdcde5300000000 */
+    4.54228639602661132812e-01,  /* 0x3fdd121500000000 */
+    4.57377910614013671875e-01,  /* 0x3fdd45ae00000000 */
+    4.60517644882202148438e-01,  /* 0x3fdd791f00000000 */
+    4.63647603988647460938e-01,  /* 0x3fddac6700000000 */
+    4.66767549514770507812e-01,  /* 0x3fdddf8500000000 */
+    4.69877958297729492188e-01,  /* 0x3fde127b00000000 */
+    4.72978591918945312500e-01,  /* 0x3fde454800000000 */
+    4.76069211959838867188e-01,  /* 0x3fde77eb00000000 */
+    4.79150056838989257812e-01,  /* 0x3fdeaa6500000000 */
+    4.82221126556396484375e-01,  /* 0x3fdedcb600000000 */
+    4.85282421112060546875e-01,  /* 0x3fdf0ede00000000 */
+    4.88333940505981445312e-01,  /* 0x3fdf40dd00000000 */
+    4.91375446319580078125e-01,  /* 0x3fdf72b200000000 */
+    4.94406938552856445312e-01,  /* 0x3fdfa45d00000000 */
+    4.97428894042968750000e-01,  /* 0x3fdfd5e000000000 */
+    5.00440597534179687500e-01,  /* 0x3fe0039c00000000 */
+    5.03442764282226562500e-01,  /* 0x3fe01c3400000000 */
+    5.06434917449951171875e-01,  /* 0x3fe034b700000000 */
+    5.09417057037353515625e-01,  /* 0x3fe04d2500000000 */
+    5.12389183044433593750e-01,  /* 0x3fe0657e00000000 */
+    5.15351772308349609375e-01,  /* 0x3fe07dc300000000 */
+    5.18304347991943359375e-01,  /* 0x3fe095f300000000 */
+    5.21246910095214843750e-01,  /* 0x3fe0ae0e00000000 */
+    5.24179458618164062500e-01,  /* 0x3fe0c61400000000 */
+    5.27101993560791015625e-01,  /* 0x3fe0de0500000000 */
+    5.30014991760253906250e-01,  /* 0x3fe0f5e200000000 */
+    5.32917976379394531250e-01,  /* 0x3fe10daa00000000 */
+    5.35810947418212890625e-01,  /* 0x3fe1255d00000000 */
+    5.38693904876708984375e-01,  /* 0x3fe13cfb00000000 */
+    5.41567325592041015625e-01,  /* 0x3fe1548500000000 */
+    5.44430732727050781250e-01,  /* 0x3fe16bfa00000000 */
+    5.47284126281738281250e-01,  /* 0x3fe1835a00000000 */
+    5.50127506256103515625e-01,  /* 0x3fe19aa500000000 */
+    5.52961349487304687500e-01,  /* 0x3fe1b1dc00000000 */
+    5.55785179138183593750e-01,  /* 0x3fe1c8fe00000000 */
+    5.58598995208740234375e-01,  /* 0x3fe1e00b00000000 */
+    5.61403274536132812500e-01,  /* 0x3fe1f70400000000 */
+    5.64197540283203125000e-01,  /* 0x3fe20de800000000 */
+    5.66981792449951171875e-01,  /* 0x3fe224b700000000 */
+    5.69756031036376953125e-01,  /* 0x3fe23b7100000000 */
+    5.72520732879638671875e-01,  /* 0x3fe2521700000000 */
+    5.75275897979736328125e-01,  /* 0x3fe268a900000000 */
+    5.78021049499511718750e-01,  /* 0x3fe27f2600000000 */
+    5.80756187438964843750e-01,  /* 0x3fe2958e00000000 */
+    5.83481788635253906250e-01,  /* 0x3fe2abe200000000 */
+    5.86197376251220703125e-01,  /* 0x3fe2c22100000000 */
+    5.88903427124023437500e-01,  /* 0x3fe2d84c00000000 */
+    5.91599464416503906250e-01,  /* 0x3fe2ee6200000000 */
+    5.94285964965820312500e-01,  /* 0x3fe3046400000000 */
+    5.96962928771972656250e-01,  /* 0x3fe31a5200000000 */
+    5.99629878997802734375e-01,  /* 0x3fe3302b00000000 */
+    6.02287292480468750000e-01,  /* 0x3fe345f000000000 */
+    6.04934692382812500000e-01,  /* 0x3fe35ba000000000 */
+    6.07573032379150390625e-01,  /* 0x3fe3713d00000000 */
+    6.10201358795166015625e-01,  /* 0x3fe386c500000000 */
+    6.12820148468017578125e-01,  /* 0x3fe39c3900000000 */
+    6.15428924560546875000e-01,  /* 0x3fe3b19800000000 */
+    6.18028640747070312500e-01,  /* 0x3fe3c6e400000000 */
+    6.20618820190429687500e-01,  /* 0x3fe3dc1c00000000 */
+    6.23198986053466796875e-01,  /* 0x3fe3f13f00000000 */
+    6.25770092010498046875e-01,  /* 0x3fe4064f00000000 */
+    6.28331184387207031250e-01,  /* 0x3fe41b4a00000000 */
+    6.30883216857910156250e-01,  /* 0x3fe4303200000000 */
+    6.33425712585449218750e-01,  /* 0x3fe4450600000000 */
+    6.35958671569824218750e-01,  /* 0x3fe459c600000000 */
+    6.38482093811035156250e-01,  /* 0x3fe46e7200000000 */
+    6.40995979309082031250e-01,  /* 0x3fe4830a00000000 */
+    6.43500804901123046875e-01,  /* 0x3fe4978f00000000 */
+    6.45996093750000000000e-01,  /* 0x3fe4ac0000000000 */
+    6.48482322692871093750e-01,  /* 0x3fe4c05e00000000 */
+    6.50959014892578125000e-01,  /* 0x3fe4d4a800000000 */
+    6.53426170349121093750e-01,  /* 0x3fe4e8de00000000 */
+    6.55884265899658203125e-01,  /* 0x3fe4fd0100000000 */
+    6.58332824707031250000e-01,  /* 0x3fe5111000000000 */
+    6.60772323608398437500e-01,  /* 0x3fe5250c00000000 */
+    6.63202762603759765625e-01,  /* 0x3fe538f500000000 */
+    6.65623664855957031250e-01,  /* 0x3fe54cca00000000 */
+    6.68035984039306640625e-01,  /* 0x3fe5608d00000000 */
+    6.70438766479492187500e-01,  /* 0x3fe5743c00000000 */
+    6.72832489013671875000e-01,  /* 0x3fe587d800000000 */
+    6.75216674804687500000e-01,  /* 0x3fe59b6000000000 */
+    6.77592277526855468750e-01,  /* 0x3fe5aed600000000 */
+    6.79958820343017578125e-01,  /* 0x3fe5c23900000000 */
+    6.82316303253173828125e-01,  /* 0x3fe5d58900000000 */
+    6.84664726257324218750e-01,  /* 0x3fe5e8c600000000 */
+    6.87004089355468750000e-01,  /* 0x3fe5fbf000000000 */
+    6.89334869384765625000e-01,  /* 0x3fe60f0800000000 */
+    6.91656589508056640625e-01,  /* 0x3fe6220d00000000 */
+    6.93969249725341796875e-01,  /* 0x3fe634ff00000000 */
+    6.96272850036621093750e-01,  /* 0x3fe647de00000000 */
+    6.98567867279052734375e-01,  /* 0x3fe65aab00000000 */
+    7.00854301452636718750e-01,  /* 0x3fe66d6600000000 */
+    7.03131675720214843750e-01,  /* 0x3fe6800e00000000 */
+    7.05400466918945312500e-01,  /* 0x3fe692a400000000 */
+    7.07660198211669921875e-01,  /* 0x3fe6a52700000000 */
+    7.09911346435546875000e-01,  /* 0x3fe6b79800000000 */
+    7.12153911590576171875e-01,  /* 0x3fe6c9f700000000 */
+    7.14387893676757812500e-01,  /* 0x3fe6dc4400000000 */
+    7.16613292694091796875e-01,  /* 0x3fe6ee7f00000000 */
+    7.18829631805419921875e-01,  /* 0x3fe700a700000000 */
+    7.21037864685058593750e-01,  /* 0x3fe712be00000000 */
+    7.23237514495849609375e-01,  /* 0x3fe724c300000000 */
+    7.25428581237792968750e-01,  /* 0x3fe736b600000000 */
+    7.27611064910888671875e-01,  /* 0x3fe7489700000000 */
+    7.29785442352294921875e-01,  /* 0x3fe75a6700000000 */
+    7.31950759887695312500e-01,  /* 0x3fe76c2400000000 */
+    7.34108448028564453125e-01,  /* 0x3fe77dd100000000 */
+    7.36257076263427734375e-01,  /* 0x3fe78f6b00000000 */
+    7.38397598266601562500e-01,  /* 0x3fe7a0f400000000 */
+    7.40530014038085937500e-01,  /* 0x3fe7b26c00000000 */
+    7.42654323577880859375e-01,  /* 0x3fe7c3d300000000 */
+    7.44770050048828125000e-01,  /* 0x3fe7d52800000000 */
+    7.46877670288085937500e-01,  /* 0x3fe7e66c00000000 */
+    7.48976707458496093750e-01,  /* 0x3fe7f79e00000000 */
+    7.51068115234375000000e-01,  /* 0x3fe808c000000000 */
+    7.53150939941406250000e-01,  /* 0x3fe819d000000000 */
+    7.55226135253906250000e-01,  /* 0x3fe82ad000000000 */
+    7.57292747497558593750e-01,  /* 0x3fe83bbe00000000 */
+    7.59351730346679687500e-01,  /* 0x3fe84c9c00000000 */
+    7.61402606964111328125e-01,  /* 0x3fe85d6900000000 */
+    7.63445377349853515625e-01,  /* 0x3fe86e2500000000 */
+    7.65480041503906250000e-01,  /* 0x3fe87ed000000000 */
+    7.67507076263427734375e-01,  /* 0x3fe88f6b00000000 */
+    7.69526004791259765625e-01,  /* 0x3fe89ff500000000 */
+    7.71537303924560546875e-01,  /* 0x3fe8b06f00000000 */
+    7.73540973663330078125e-01,  /* 0x3fe8c0d900000000 */
+    7.75536537170410156250e-01,  /* 0x3fe8d13200000000 */
+    7.77523994445800781250e-01,  /* 0x3fe8e17a00000000 */
+    7.79504299163818359375e-01,  /* 0x3fe8f1b300000000 */
+    7.81476497650146484375e-01,  /* 0x3fe901db00000000 */
+    7.83441066741943359375e-01,  /* 0x3fe911f300000000 */
+    7.85398006439208984375e-01}; /* 0x3fe921fb00000000 */
+
+  static const double atan_jby256_tail[  241] = {
+    2.13244638182005395671e-08,  /* 0x3e56e59fbd38db2c */
+    3.89093864761712760656e-08,  /* 0x3e64e3aa54dedf96 */
+    4.44780900009437454576e-08,  /* 0x3e67e105ab1bda88 */
+    1.15344768460112754160e-08,  /* 0x3e48c5254d013fd0 */
+    3.37271051945395312705e-09,  /* 0x3e2cf8ab3ad62670 */
+    2.40857608736109859459e-08,  /* 0x3e59dca4bec80468 */
+    1.85853810450623807768e-08,  /* 0x3e53f4b5ec98a8da */
+    5.14358299969225078306e-08,  /* 0x3e6b9d49619d81fe */
+    8.85023985412952486748e-09,  /* 0x3e43017887460934 */
+    1.59425154214358432060e-08,  /* 0x3e511e3eca0b9944 */
+    1.95139937737755753164e-08,  /* 0x3e54f3f73c5a332e */
+    2.64909755273544319715e-08,  /* 0x3e5c71c8ae0e00a6 */
+    4.43388037881231070144e-08,  /* 0x3e67cde0f86fbdc7 */
+    2.14757072421821274557e-08,  /* 0x3e570f328c889c72 */
+    2.61049792670754218852e-08,  /* 0x3e5c07ae9b994efe */
+    7.81439350674466302231e-09,  /* 0x3e40c8021d7b1698 */
+    3.60125207123751024094e-08,  /* 0x3e635585edb8cb22 */
+    6.15276238179343767917e-08,  /* 0x3e70842567b30e96 */
+    9.54387964641184285058e-08,  /* 0x3e799e811031472e */
+    3.02789566851502754129e-08,  /* 0x3e6041821416bcee */
+    1.16888650949870856331e-07,  /* 0x3e7f6086e4dc96f4 */
+    1.07580956468653338863e-08,  /* 0x3e471a535c5f1b58 */
+    8.33454265379535427653e-08,  /* 0x3e765f743fe63ca1 */
+    1.10790279272629526068e-07,  /* 0x3e7dbd733472d014 */
+    1.08394277896366207424e-07,  /* 0x3e7d18cc4d8b0d1d */
+    9.22176086126841098800e-08,  /* 0x3e78c12553c8fb29 */
+    7.90938592199048786990e-08,  /* 0x3e753b49e2e8f991 */
+    8.66445407164293125637e-08,  /* 0x3e77422ae148c141 */
+    1.40839973537092438671e-08,  /* 0x3e4e3ec269df56a8 */
+    1.19070438507307600689e-07,  /* 0x3e7ff6754e7e0ac9 */
+    6.40451663051716197071e-08,  /* 0x3e7131267b1b5aad */
+    1.08338682076343674522e-07,  /* 0x3e7d14fa403a94bc */
+    3.52999550187922736222e-08,  /* 0x3e62f396c089a3d8 */
+    1.05983273930043077202e-07,  /* 0x3e7c731d78fa95bb */
+    1.05486124078259553339e-07,  /* 0x3e7c50f385177399 */
+    5.82167732281776477773e-08,  /* 0x3e6f41409c6f2c20 */
+    1.08696483983403942633e-07,  /* 0x3e7d2d90c4c39ec0 */
+    4.47335086122377542835e-08,  /* 0x3e680420696f2106 */
+    1.26896287162615723528e-08,  /* 0x3e4b40327943a2e8 */
+    4.06534471589151404531e-08,  /* 0x3e65d35e02f3d2a2 */
+    3.84504846300557026690e-08,  /* 0x3e64a498288117b0 */
+    3.60715006404807269080e-08,  /* 0x3e635da119afb324 */
+    6.44725903165522722801e-08,  /* 0x3e714e85cdb9a908 */
+    3.63749249976409461305e-08,  /* 0x3e638754e5547b9a */
+    1.03901294413833913794e-07,  /* 0x3e7be40ae6ce3246 */
+    6.25379756302167880580e-08,  /* 0x3e70c993b3bea7e7 */
+    6.63984302368488828029e-08,  /* 0x3e71d2dd89ac3359 */
+    3.21844598971548278059e-08,  /* 0x3e61476603332c46 */
+    1.16030611712765830905e-07,  /* 0x3e7f25901bac55b7 */
+    1.17464622142347730134e-07,  /* 0x3e7f881b7c826e28 */
+    7.54604017965808996596e-08,  /* 0x3e7441996d698d20 */
+    1.49234929356206556899e-07,  /* 0x3e8407ac521ea089 */
+    1.41416924523217430259e-07,  /* 0x3e82fb0c6c4b1723 */
+    2.13308065617483489011e-07,  /* 0x3e8ca135966a3e18 */
+    5.04230937933302320146e-08,  /* 0x3e6b1218e4d646e4 */
+    5.45874922281655519035e-08,  /* 0x3e6d4e72a350d288 */
+    1.51849028914786868886e-07,  /* 0x3e84617e2f04c329 */
+    3.09004308703769273010e-08,  /* 0x3e6096ec41e82650 */
+    9.67574548184738317664e-08,  /* 0x3e79f91f25773e6e */
+    4.02508285529322212824e-08,  /* 0x3e659c0820f1d674 */
+    3.01222268096861091157e-08,  /* 0x3e602bf7a2df1064 */
+    2.36189860670079288680e-07,  /* 0x3e8fb36bfc40508f */
+    1.14095158111080887695e-07,  /* 0x3e7ea08f3f8dc892 */
+    7.42349089746573467487e-08,  /* 0x3e73ed6254656a0e */
+    5.12515583196230380184e-08,  /* 0x3e6b83f5e5e69c58 */
+    2.19290391828763918102e-07,  /* 0x3e8d6ec2af768592 */
+    3.83263512187553886471e-08,  /* 0x3e6493889a226f94 */
+    1.61513486284090523855e-07,  /* 0x3e85ad8fa65279ba */
+    5.09996743535589922261e-08,  /* 0x3e6b615784d45434 */
+    1.23694037861246766534e-07,  /* 0x3e809a184368f145 */
+    8.23367955351123783984e-08,  /* 0x3e761a2439b0d91c */
+    1.07591766213053694014e-07,  /* 0x3e7ce1a65e39a978 */
+    1.42789947524631815640e-07,  /* 0x3e832a39a93b6a66 */
+    1.32347123024711878538e-07,  /* 0x3e81c3699af804e7 */
+    2.17626067316598149229e-08,  /* 0x3e575e0f4e44ede8 */
+    2.34454866923044288656e-07,  /* 0x3e8f77ced1a7a83b */
+    2.82966370261766916053e-09,  /* 0x3e284e7f0cb1b500 */
+    2.29300919890907632975e-07,  /* 0x3e8ec6b838b02dfe */
+    1.48428270450261284915e-07,  /* 0x3e83ebf4dfbeda87 */
+    1.87937408574313982512e-07,  /* 0x3e89397aed9cb475 */
+    6.13685946813334055347e-08,  /* 0x3e707937bc239c54 */
+    1.98585022733583817493e-07,  /* 0x3e8aa754553131b6 */
+    7.68394131623752961662e-08,  /* 0x3e74a05d407c45dc */
+    1.28119052312436745644e-07,  /* 0x3e8132231a206dd0 */
+    7.02119104719236502733e-08,  /* 0x3e72d8ecfdd69c88 */
+    9.87954793820636301943e-08,  /* 0x3e7a852c74218606 */
+    1.72176752381034986217e-07,  /* 0x3e871bf2baeebb50 */
+    1.12877225146169704119e-08,  /* 0x3e483d7db7491820 */
+    5.33549829555851737993e-08,  /* 0x3e6ca50d92b6da14 */
+    2.13833275710816521345e-08,  /* 0x3e56f5cde8530298 */
+    1.16243518048290556393e-07,  /* 0x3e7f343198910740 */
+    6.29926408369055877943e-08,  /* 0x3e70e8d241ccd80a */
+    6.45429039328021963791e-08,  /* 0x3e71535ac619e6c8 */
+    8.64001922814281933403e-08,  /* 0x3e77316041c36cd2 */
+    9.50767572202325800240e-08,  /* 0x3e7985a000637d8e */
+    5.80851497508121135975e-08,  /* 0x3e6f2f29858c0a68 */
+    1.82350561135024766232e-07,  /* 0x3e8879847f96d909 */
+    1.98948680587390608655e-07,  /* 0x3e8ab3d319e12e42 */
+    7.83548663450197659846e-08,  /* 0x3e75088162dfc4c2 */
+    3.04374234486798594427e-08,  /* 0x3e605749a1cd9d8c */
+    2.76135725629797411787e-08,  /* 0x3e5da65c6c6b8618 */
+    4.32610105454203065470e-08,  /* 0x3e6739bf7df1ad64 */
+    5.17107515324127256994e-08,  /* 0x3e6bc31252aa3340 */
+    2.82398327875841444660e-08,  /* 0x3e5e528191ad3aa8 */
+    1.87482469524195595399e-07,  /* 0x3e8929d93df19f18 */
+    2.97481891662714096139e-08,  /* 0x3e5ff11eb693a080 */
+    9.94421570843584316402e-09,  /* 0x3e455ae3f145a3a0 */
+    1.07056210730391848428e-07,  /* 0x3e7cbcd8c6c0ca82 */
+    6.25589580466881163081e-08,  /* 0x3e70cb04d425d304 */
+    9.56641013869464593803e-08,  /* 0x3e79adfcab5be678 */
+    1.88056307148355440276e-07,  /* 0x3e893d90c5662508 */
+    8.38850689379557880950e-08,  /* 0x3e768489bd35ff40 */
+    5.01215865527674122924e-09,  /* 0x3e3586ed3da2b7e0 */
+    1.74166095998522089762e-07,  /* 0x3e87604d2e850eee */
+    9.96779574395363585849e-08,  /* 0x3e7ac1d12bfb53d8 */
+    5.98432026368321460686e-09,  /* 0x3e39b3d468274740 */
+    1.18362922366887577169e-07,  /* 0x3e7fc5d68d10e53c */
+    1.86086833284154215946e-07,  /* 0x3e88f9e51884becb */
+    1.97671457251348941011e-07,  /* 0x3e8a87f0869c06d1 */
+    1.42447160717199237159e-07,  /* 0x3e831e7279f685fa */
+    1.05504240785546574184e-08,  /* 0x3e46a8282f9719b0 */
+    3.13335218371639189324e-08,  /* 0x3e60d2724a8a44e0 */
+    1.96518418901914535399e-07,  /* 0x3e8a60524b11ad4e */
+    2.17692035039173536059e-08,  /* 0x3e575fdf832750f0 */
+    2.15613114426529981675e-07,  /* 0x3e8cf06902e4cd36 */
+    5.68271098300441214948e-08,  /* 0x3e6e82422d4f6d10 */
+    1.70331455823369124256e-08,  /* 0x3e524a091063e6c0 */
+    9.17590028095709583247e-08,  /* 0x3e78a1a172dc6f38 */
+    2.77266304112916566247e-07,  /* 0x3e929b6619f8a92d */
+    9.37041937614656939690e-08,  /* 0x3e79274d9c1b70c8 */
+    1.56116346368316796511e-08,  /* 0x3e50c34b1fbb7930 */
+    4.13967433808382727413e-08,  /* 0x3e6639866c20eb50 */
+    1.70164749185821616276e-07,  /* 0x3e86d6d0f6832e9e */
+    4.01708788545600086008e-07,  /* 0x3e9af54def99f25e */
+    2.59663539226050551563e-07,  /* 0x3e916cfc52a00262 */
+    2.22007487655027469542e-07,  /* 0x3e8dcc1e83569c32 */
+    2.90542250809644081369e-07,  /* 0x3e937f7a551ed425 */
+    4.67720537666628903341e-07,  /* 0x3e9f6360adc98887 */
+    2.79799803956772554802e-07,  /* 0x3e92c6ec8d35a2c1 */
+    2.07344552327432547723e-07,  /* 0x3e8bd44df84cb036 */
+    2.54705698692735196368e-07,  /* 0x3e9117cf826e310e */
+    4.26848589539548450728e-07,  /* 0x3e9ca533f332cfc9 */
+    2.52506723633552216197e-07,  /* 0x3e90f208509dbc2e */
+    2.14684129933849704964e-07,  /* 0x3e8cd07d93c945de */
+    3.20134822201596505431e-07,  /* 0x3e957bdfd67e6d72 */
+    9.93537565749855712134e-08,  /* 0x3e7aab89c516c658 */
+    3.70792944827917252327e-08,  /* 0x3e63e823b1a1b8a0 */
+    1.41772749369083698972e-07,  /* 0x3e8307464a9d6d3c */
+    4.22446601490198804306e-07,  /* 0x3e9c5993cd438843 */
+    4.11818433724801511540e-07,  /* 0x3e9ba2fca02ab554 */
+    1.19976381502605310519e-07,  /* 0x3e801a5b6983a268 */
+    3.43703078571520905265e-08,  /* 0x3e6273d1b350efc8 */
+    1.66128705555453270379e-07,  /* 0x3e864c238c37b0c6 */
+    5.00499610023283006540e-08,  /* 0x3e6aded07370a300 */
+    1.75105139941208062123e-07,  /* 0x3e878091197eb47e */
+    7.70807146729030327334e-08,  /* 0x3e74b0f245e0dabc */
+    2.45918607526895836121e-07,  /* 0x3e9080d9794e2eaf */
+    2.18359020958626199345e-07,  /* 0x3e8d4ec242b60c76 */
+    8.44342887976445333569e-09,  /* 0x3e4221d2f940caa0 */
+    1.07506148687888629299e-07,  /* 0x3e7cdbc42b2bba5c */
+    5.36544954316820904572e-08,  /* 0x3e6cce37bb440840 */
+    3.39109101518396596341e-07,  /* 0x3e96c1d999cf1dd0 */
+    2.60098720293920613340e-08,  /* 0x3e5bed8a07eb0870 */
+    8.42678991664621455827e-08,  /* 0x3e769ed88f490e3c */
+    5.36972237470183633197e-08,  /* 0x3e6cd41719b73ef0 */
+    4.28192558171921681288e-07,  /* 0x3e9cbc4ac95b41b7 */
+    2.71535491483955143294e-07,  /* 0x3e9238f1b890f5d7 */
+    7.84094998145075780203e-08,  /* 0x3e750c4282259cc4 */
+    3.43880599134117431863e-07,  /* 0x3e9713d2de87b3e2 */
+    1.32878065060366481043e-07,  /* 0x3e81d5a7d2255276 */
+    4.18046802627967629428e-07,  /* 0x3e9c0dfd48227ac1 */
+    2.65042411765766019424e-07,  /* 0x3e91c964dab76753 */
+    1.70383695347518643694e-07,  /* 0x3e86de56d5704496 */
+    1.54096497259613515678e-07,  /* 0x3e84aeb71fd19968 */
+    2.36543402412459813461e-07,  /* 0x3e8fbf91c57b1918 */
+    4.38416350106876736790e-07,  /* 0x3e9d6bef7fbe5d9a */
+    3.03892161339927775731e-07,  /* 0x3e9464d3dc249066 */
+    3.31136771605664899240e-07,  /* 0x3e9638e2ec4d9073 */
+    6.49494294526590682218e-08,  /* 0x3e716f4a7247ea7c */
+    4.10423429887181345747e-09,  /* 0x3e31a0a740f1d440 */
+    1.70831640869113847224e-07,  /* 0x3e86edbb0114a33c */
+    1.10811512657909180966e-07,  /* 0x3e7dbee8bf1d513c */
+    3.23677724749783611964e-07,  /* 0x3e95b8bdb0248f73 */
+    3.55662734259192678528e-07,  /* 0x3e97de3d3f5eac64 */
+    2.30102333489738219140e-07,  /* 0x3e8ee24187ae448a */
+    4.47429004000738629714e-07,  /* 0x3e9e06c591ec5192 */
+    7.78167135617329598659e-08,  /* 0x3e74e3861a332738 */
+    9.90345291908535415737e-08,  /* 0x3e7a9599dcc2bfe4 */
+    5.85800913143113728314e-08,  /* 0x3e6f732fbad43468 */
+    4.57859062410871843857e-07,  /* 0x3e9eb9f573b727d9 */
+    3.67993069723390929794e-07,  /* 0x3e98b212a2eb9897 */
+    2.90836464322977276043e-07,  /* 0x3e9384884c167215 */
+    2.51621574250131388318e-07,  /* 0x3e90e2d363020051 */
+    2.75789824740652815545e-07,  /* 0x3e92820879fbd022 */
+    3.88985776250314403593e-07,  /* 0x3e9a1ab9893e4b30 */
+    1.40214080183768019611e-07,  /* 0x3e82d1b817a24478 */
+    3.23451432223550478373e-08,  /* 0x3e615d7b8ded4878 */
+    9.15979180730608444470e-08,  /* 0x3e78968f9db3a5e4 */
+    3.44371402498640470421e-07,  /* 0x3e971c4171fe135f */
+    3.40401897215059498077e-07,  /* 0x3e96d80f605d0d8c */
+    1.06431813453707950243e-07,  /* 0x3e7c91f043691590 */
+    1.46204238932338846248e-07,  /* 0x3e839f8a15fce2b2 */
+    9.94610376972039046878e-09,  /* 0x3e455beda9d94b80 */
+    2.01711528092681771039e-07,  /* 0x3e8b12c15d60949a */
+    2.72027977986191568296e-07,  /* 0x3e924167b312bfe3 */
+    2.48402602511693757964e-07,  /* 0x3e90ab8633070277 */
+    1.58480011219249621715e-07,  /* 0x3e854554ebbc80ee */
+    3.00372828113368713281e-08,  /* 0x3e60204aef5a4bb8 */
+    3.67816204583541976394e-07,  /* 0x3e98af08c679cf2c */
+    2.46169793032343824291e-07,  /* 0x3e90852a330ae6c8 */
+    1.70080468270204253247e-07,  /* 0x3e86d3eb9ec32916 */
+    1.67806717763872914315e-07,  /* 0x3e8685cb7fcbbafe */
+    2.67715622006907942620e-07,  /* 0x3e91f751c1e0bd95 */
+    2.14411342550299170574e-08,  /* 0x3e5705b1b0f72560 */
+    4.11228221283669073277e-07,  /* 0x3e9b98d8d808ca92 */
+    3.52311752396749662260e-08,  /* 0x3e62ea22c75cc980 */
+    3.52718000397367821054e-07,  /* 0x3e97aba62bca0350 */
+    4.38857387992911129814e-07,  /* 0x3e9d73833442278c */
+    3.22574606753482540743e-07,  /* 0x3e95a5ca1fb18bf9 */
+    3.28730371182804296828e-08,  /* 0x3e61a6092b6ecf28 */
+    7.56672470607639279700e-08,  /* 0x3e744fd049aac104 */
+    3.26750155316369681821e-09,  /* 0x3e2c114fd8df5180 */
+    3.21724445362095284743e-07,  /* 0x3e95972f130feae5 */
+    1.06639427371776571151e-07,  /* 0x3e7ca034a55fe198 */
+    3.41020788139524715063e-07,  /* 0x3e96e2b149990227 */
+    1.00582838631232552824e-07,  /* 0x3e7b00000294592c */
+    3.68439433859276640065e-07,  /* 0x3e98b9bdc442620e */
+    2.20403078342388012027e-07,  /* 0x3e8d94fdfabf3e4e */
+    1.62841467098298142534e-07,  /* 0x3e85db30b145ad9a */
+    2.25325348296680733838e-07,  /* 0x3e8e3e1eb95022b0 */
+    4.37462238226421614339e-07,  /* 0x3e9d5b8b45442bd6 */
+    3.52055880555040706500e-07,  /* 0x3e97a046231ecd2e */
+    4.75614398494781776825e-07,  /* 0x3e9feafe3ef55232 */
+    3.60998399033215317516e-07,  /* 0x3e9839e7bfd78267 */
+    3.79292434611513945954e-08,  /* 0x3e645cf49d6fa900 */
+    1.29859015528549300061e-08,  /* 0x3e4be3132b27f380 */
+    3.15927546985474913188e-07,  /* 0x3e9533980bb84f9f */
+    2.28533679887379668031e-08,  /* 0x3e5889e2ce3ba390 */
+    1.17222541823553133877e-07,  /* 0x3e7f7778c3ad0cc8 */
+    1.51991208405464415857e-07,  /* 0x3e846660cec4eba2 */
+    1.56958239325240655564e-07}; /* 0x3e85110b4611a626 */
+
+  /* Some constants and split constants. */
+
+  static double pi = 3.1415926535897932e+00, /* 0x400921fb54442d18 */
+             piby2 = 1.5707963267948966e+00, /* 0x3ff921fb54442d18 */
+             piby4 = 7.8539816339744831e-01, /* 0x3fe921fb54442d18 */
+       three_piby4 = 2.3561944901923449e+00, /* 0x4002d97c7f3321d2 */
+           pi_head = 3.1415926218032836e+00, /* 0x400921fb50000000 */
+           pi_tail = 3.1786509547056392e-08, /* 0x3e6110b4611a6263 */
+        piby2_head = 1.5707963267948965e+00, /* 0x3ff921fb54442d18 */
+        piby2_tail = 6.1232339957367660e-17; /* 0x3c91a62633145c07 */
+
+  double u, v, vbyu, q1, q2, s, u1, vu1, u2, vu2, uu, c, r;
+  unsigned int swap_vu, index, xzero, yzero, xnan, ynan, xinf, yinf;
+  int m, xexp, yexp, diffexp;
+
+  /* Find properties of arguments x and y. */
+
+  unsigned long long ux, ui, aux, xneg, uy, auy, yneg;
+
+  GET_BITS_DP64(x, ux);
+  GET_BITS_DP64(y, uy);
+  aux = ux & ~SIGNBIT_DP64;
+  auy = uy & ~SIGNBIT_DP64;
+  xexp = (int)((ux & EXPBITS_DP64) >> EXPSHIFTBITS_DP64);
+  yexp = (int)((uy & EXPBITS_DP64) >> EXPSHIFTBITS_DP64);
+  xneg = ux & SIGNBIT_DP64;
+  yneg = uy & SIGNBIT_DP64;
+  xzero = (aux == 0);
+  yzero = (auy == 0);
+  xnan = (aux > PINFBITPATT_DP64);
+  ynan = (auy > PINFBITPATT_DP64);
+  xinf = (aux == PINFBITPATT_DP64);
+  yinf = (auy == PINFBITPATT_DP64);
+
+  diffexp = yexp - xexp;
+
+  /* Special cases */
+
+  if (xnan)
+#ifdef WINDOWS
+    return handle_error("atan2", ux|0x0008000000000000, _DOMAIN, 0,
+                        EDOM, x, y);
+#else
+    return x + x; /* Raise invalid if it's a signalling NaN */
+#endif
+  else if (ynan)
+#ifdef WINDOWS
+    return handle_error("atan2", uy|0x0008000000000000, _DOMAIN, 0,
+                        EDOM, x, y);
+#else
+    return y + y; /* Raise invalid if it's a signalling NaN */
+#endif
+  else if (yzero)
+    { /* Zero y gives +-0 for positive x
+         and +-pi for negative x */
+#ifndef WINDOWS
+      if ((_LIB_VERSION == _SVID_) && xzero)
+        /* Sigh - _SVID_ defines atan2(0,0) as a domain error */
+        return retval_errno_edom(x, y);
+      else
+#endif
+      if (xneg)
+	{
+	  if (yneg) return val_with_flags(-pi,AMD_F_INEXACT);
+          else return val_with_flags(pi,AMD_F_INEXACT);
+	}
+      else return y;
+    }
+  else if (xzero)
+    { /* Zero x gives +- pi/2
+         depending on sign of y */
+      if (yneg) return val_with_flags(-piby2,AMD_F_INEXACT);
+      else val_with_flags(piby2,AMD_F_INEXACT);
+    }
+
+  /* Scale up both x and y if they are both below 1/4.
+     This avoids any possible later denormalised arithmetic. */
+
+  if ((xexp < 1021 && yexp < 1021))
+    {
+      scaleUpDouble1024(ux, &ux);
+      scaleUpDouble1024(uy, &uy);
+      PUT_BITS_DP64(ux, x);
+      PUT_BITS_DP64(uy, y);
+      xexp = (int)((ux & EXPBITS_DP64) >> EXPSHIFTBITS_DP64);
+      yexp = (int)((uy & EXPBITS_DP64) >> EXPSHIFTBITS_DP64);
+      diffexp = yexp - xexp;
+    }
+
+  if (diffexp > 56)
+    { /* abs(y)/abs(x) > 2^56 => arctan(x/y)
+         is insignificant compared to piby2 */
+      if (yneg) return val_with_flags(-piby2,AMD_F_INEXACT);
+      else return val_with_flags(piby2,AMD_F_INEXACT);
+    }
+  else if (diffexp < -28 && (!xneg))
+    { /* x positive and dominant over y by a factor of 2^28.
+         In this case atan(y/x) is y/x to machine accuracy. */
+
+      if (diffexp < -1074) /* Result underflows */
+        {
+          if (yneg)
+            return val_with_flags(-0.0,AMD_F_INEXACT | AMD_F_UNDERFLOW);
+          else
+            return val_with_flags(0.0,AMD_F_INEXACT | AMD_F_UNDERFLOW);
+        }
+      else
+        {
+          if (diffexp < -1022)
+            {
+              /* Result will likely be denormalized */
+              y = scaleDouble_1(y, 100);
+              y /= x;
+              /* Now y is 2^100 times the true result. Scale it back down. */
+              GET_BITS_DP64(y, uy);
+	      scaleDownDouble(uy, 100, &uy);
+              PUT_BITS_DP64(uy, y);
+	      if ((uy & EXPBITS_DP64) == 0)
+		return val_with_flags(y, AMD_F_INEXACT | AMD_F_UNDERFLOW);
+	      else
+		return y;
+             }
+          else
+            return y / x;
+        }
+    }
+  else if (diffexp < -56 && xneg)
+    { /* abs(x)/abs(y) > 2^56 and x < 0 => arctan(y/x)
+         is insignificant compared to pi */
+    if (yneg) return val_with_flags(-pi,AMD_F_INEXACT);
+    else return val_with_flags(pi,AMD_F_INEXACT);
+    }
+  else if (yinf && xinf)
+    { /* If abs(x) and abs(y) are both infinity
+         return +-pi/4 or +- 3pi/4 according to
+         signs.  */
+    if (xneg)
+      {
+      if (yneg) return val_with_flags(-three_piby4,AMD_F_INEXACT);
+      else return val_with_flags(three_piby4,AMD_F_INEXACT);
+      }
+    else
+      {
+      if (yneg) return val_with_flags(-piby4,AMD_F_INEXACT);
+      else return val_with_flags(piby4,AMD_F_INEXACT);
+      }
+    }
+
+  /* General case: take absolute values of arguments */
+
+  u = x; v = y;
+  if (xneg) u = -x;
+  if (yneg) v = -y;
+
+  /* Swap u and v if necessary to obtain 0 < v < u. Compute v/u. */
+
+  swap_vu = (u < v);
+  if (swap_vu) { uu = u; u = v; v = uu; }
+  vbyu = v/u;
+
+  if (vbyu > 0.0625)
+    { /* General values of v/u. Use a look-up
+         table and series expansion. */
+
+      index = (int)(256*vbyu + 0.5);
+      q1 = atan_jby256_lead[index-16];
+      q2 = atan_jby256_tail[index-16];
+      c = index*1./256;
+      GET_BITS_DP64(u, ui);
+      m = (int)((ui & EXPBITS_DP64) >> EXPSHIFTBITS_DP64) - EXPBIAS_DP64;
+      u = scaleDouble_2(u,-m);
+      v = scaleDouble_2(v,-m);
+      GET_BITS_DP64(u, ui);
+      PUT_BITS_DP64(0xfffffffff8000000 & ui, u1); /* 26 leading bits of u */
+      u2 = u - u1;
+
+      r = ((v-c*u1)-c*u2)/(u+c*v);
+
+      /* Polynomial approximation to atan(r) */
+
+      s = r*r;
+      q2 = q2 + r - r*(s * (0.33333333333224095522 - s*(0.19999918038989143496)));
+    }
+  else if (vbyu < 1.e-8)
+    { /* v/u is small enough that atan(v/u) = v/u */
+      q1 = 0.0;
+      q2 = vbyu;
+    }
+  else  /* vbyu <= 0.0625 */
+    {
+      /* Small values of v/u. Use a series expansion
+	 computed carefully to minimise cancellation */
+
+      GET_BITS_DP64(u, ui);
+      PUT_BITS_DP64(0xffffffff00000000 & ui, u1);
+      GET_BITS_DP64(vbyu, ui);
+      PUT_BITS_DP64(0xffffffff00000000 & ui, vu1);
+      u2 = u - u1;
+      vu2 = vbyu - vu1;
+
+      q1 = 0.0;
+      s  = vbyu*vbyu;
+      q2 = vbyu +
+	((((v - u1*vu1) - u2*vu1) - u*vu2)/u -
+	 (vbyu*s*(0.33333333333333170500 -
+		  s*(0.19999999999393223405 -
+		     s*(0.14285713561807169030 -
+			s*(0.11110736283514525407 -
+			   s*(0.90029810285449784439E-01)))))));
+    }
+
+  /* Tidy-up according to which quadrant the arguments lie in */
+
+  if (swap_vu) {q1 = piby2_head - q1; q2 = piby2_tail - q2;}
+  if (xneg) {q1 = pi_head - q1; q2 = pi_tail - q2;}
+  q1 = q1 + q2;
+
+  if (yneg) q1 = - q1;
+
+  return q1;
+}
+
+weak_alias (__atan2, atan2)
diff --git a/src/atan2f.c b/src/atan2f.c
new file mode 100644
index 0000000..9b53c6f
--- /dev/null
+++ b/src/atan2f.c
@@ -0,0 +1,500 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#define USE_VALF_WITH_FLAGS
+#define USE_NAN_WITH_FLAGS
+#define USE_SCALEDOUBLE_1
+#define USE_SCALEDOWNDOUBLE
+#define USE_HANDLE_ERRORF
+#include "../inc/libm_inlines_amd.h"
+#undef USE_VALF_WITH_FLAGS
+#undef USE_NAN_WITH_FLAGS
+#undef USE_SCALEDOUBLE_1
+#undef USE_SCALEDOWNDOUBLE
+#undef USE_HANDLE_ERRORF
+
+#include "../inc/libm_errno_amd.h"
+
+#ifndef WINDOWS
+/* Deal with errno for out-of-range arguments
+   (only used when _LIB_VERSION is _SVID_) */
+static inline float retval_errno_edom(float x, float y)
+{
+  struct exception exc;
+  exc.arg1 = (double)x;
+  exc.arg2 = (double)y;
+  exc.type = DOMAIN;
+  exc.name = (char *)"atan2f";
+  exc.retval = HUGE;
+  if (!matherr(&exc))
+    {
+      (void)fputs("atan2f: DOMAIN error\n", stderr);
+      __set_errno(EDOM);
+    }
+  return exc.retval;
+}
+#endif
+
+#ifdef WINDOWS
+#pragma function(atan2f)
+#endif
+
+float FN_PROTOTYPE(atan2f)(float fy, float fx)
+{
+  /* Array atan_jby256 contains precomputed values of atan(j/256),
+     for j = 16, 17, ..., 256. */
+
+  static const double atan_jby256[  241] = {
+    6.24188099959573430842e-02,  /* 0x3faff55bb72cfde9 */
+    6.63088949198234745008e-02,  /* 0x3fb0f99ea71d52a6 */
+    7.01969710718705064423e-02,  /* 0x3fb1f86dbf082d58 */
+    7.40829225490337306415e-02,  /* 0x3fb2f719318a4a9a */
+    7.79666338315423007588e-02,  /* 0x3fb3f59f0e7c559d */
+    8.18479898030765457007e-02,  /* 0x3fb4f3fd677292fb */
+    8.57268757707448092464e-02,  /* 0x3fb5f2324fd2d7b2 */
+    8.96031774848717321724e-02,  /* 0x3fb6f03bdcea4b0c */
+    9.34767811585894559112e-02,  /* 0x3fb7ee182602f10e */
+    9.73475734872236708739e-02,  /* 0x3fb8ebc54478fb28 */
+    1.01215441667466668485e-01,  /* 0x3fb9e94153cfdcf1 */
+    1.05080273416329528224e-01,  /* 0x3fbae68a71c722b8 */
+    1.08941956989865793015e-01,  /* 0x3fbbe39ebe6f07c3 */
+    1.12800381201659388752e-01,  /* 0x3fbce07c5c3cca32 */
+    1.16655435441069349478e-01,  /* 0x3fbddd21701eba6e */
+    1.20507009691224548087e-01,  /* 0x3fbed98c2190043a */
+    1.24354994546761424279e-01,  /* 0x3fbfd5ba9aac2f6d */
+    1.28199281231298117811e-01,  /* 0x3fc068d584212b3d */
+    1.32039761614638734288e-01,  /* 0x3fc0e6adccf40881 */
+    1.35876328229701304195e-01,  /* 0x3fc1646541060850 */
+    1.39708874289163620386e-01,  /* 0x3fc1e1fafb043726 */
+    1.43537293701821222491e-01,  /* 0x3fc25f6e171a535c */
+    1.47361481088651630200e-01,  /* 0x3fc2dcbdb2fba1ff */
+    1.51181331798580037562e-01,  /* 0x3fc359e8edeb99a3 */
+    1.54996741923940972718e-01,  /* 0x3fc3d6eee8c6626c */
+    1.58807608315631065832e-01,  /* 0x3fc453cec6092a9e */
+    1.62613828597948567589e-01,  /* 0x3fc4d087a9da4f17 */
+    1.66415301183114927586e-01,  /* 0x3fc54d18ba11570a */
+    1.70211925285474380276e-01,  /* 0x3fc5c9811e3ec269 */
+    1.74003600935367680469e-01,  /* 0x3fc645bfffb3aa73 */
+    1.77790228992676047071e-01,  /* 0x3fc6c1d4898933d8 */
+    1.81571711160032150945e-01,  /* 0x3fc73dbde8a7d201 */
+    1.85347949995694760705e-01,  /* 0x3fc7b97b4bce5b02 */
+    1.89118848926083965578e-01,  /* 0x3fc8350be398ebc7 */
+    1.92884312257974643856e-01,  /* 0x3fc8b06ee2879c28 */
+    1.96644245190344985064e-01,  /* 0x3fc92ba37d050271 */
+    2.00398553825878511514e-01,  /* 0x3fc9a6a8e96c8626 */
+    2.04147145182116990236e-01,  /* 0x3fca217e601081a5 */
+    2.07889927202262986272e-01,  /* 0x3fca9c231b403279 */
+    2.11626808765629753628e-01,  /* 0x3fcb1696574d780b */
+    2.15357699697738047551e-01,  /* 0x3fcb90d7529260a2 */
+    2.19082510780057748701e-01,  /* 0x3fcc0ae54d768466 */
+    2.22801153759394493514e-01,  /* 0x3fcc84bf8a742e6d */
+    2.26513541356919617664e-01,  /* 0x3fccfe654e1d5395 */
+    2.30219587276843717927e-01,  /* 0x3fcd77d5df205736 */
+    2.33919206214733416127e-01,  /* 0x3fcdf110864c9d9d */
+    2.37612313865471241892e-01,  /* 0x3fce6a148e96ec4d */
+    2.41298826930858800743e-01,  /* 0x3fcee2e1451d980c */
+    2.44978663126864143473e-01,  /* 0x3fcf5b75f92c80dd */
+    2.48651741190513253521e-01,  /* 0x3fcfd3d1fc40dbe4 */
+    2.52317980886427151166e-01,  /* 0x3fd025fa510665b5 */
+    2.55977303013005474952e-01,  /* 0x3fd061eea03d6290 */
+    2.59629629408257511791e-01,  /* 0x3fd09dc597d86362 */
+    2.63274882955282396590e-01,  /* 0x3fd0d97ee509acb3 */
+    2.66912987587400396539e-01,  /* 0x3fd1151a362431c9 */
+    2.70543868292936529052e-01,  /* 0x3fd150973a9ce546 */
+    2.74167451119658789338e-01,  /* 0x3fd18bf5a30bf178 */
+    2.77783663178873208022e-01,  /* 0x3fd1c735212dd883 */
+    2.81392432649178403370e-01,  /* 0x3fd2025567e47c95 */
+    2.84993688779881237938e-01,  /* 0x3fd23d562b381041 */
+    2.88587361894077354396e-01,  /* 0x3fd278372057ef45 */
+    2.92173383391398755471e-01,  /* 0x3fd2b2f7fd9b5fe2 */
+    2.95751685750431536626e-01,  /* 0x3fd2ed987a823cfe */
+    2.99322202530807379706e-01,  /* 0x3fd328184fb58951 */
+    3.02884868374971361060e-01,  /* 0x3fd362773707ebcb */
+    3.06439619009630070945e-01,  /* 0x3fd39cb4eb76157b */
+    3.09986391246883430384e-01,  /* 0x3fd3d6d129271134 */
+    3.13525122985043869228e-01,  /* 0x3fd410cbad6c7d32 */
+    3.17055753209146973237e-01,  /* 0x3fd44aa436c2af09 */
+    3.20578221991156986359e-01,  /* 0x3fd4845a84d0c21b */
+    3.24092470489871664618e-01,  /* 0x3fd4bdee586890e6 */
+    3.27598440950530811477e-01,  /* 0x3fd4f75f73869978 */
+    3.31096076704132047386e-01,  /* 0x3fd530ad9951cd49 */
+    3.34585322166458920545e-01,  /* 0x3fd569d88e1b4cd7 */
+    3.38066122836825466713e-01,  /* 0x3fd5a2e0175e0f4e */
+    3.41538425296541714449e-01,  /* 0x3fd5dbc3fbbe768d */
+    3.45002177207105076295e-01,  /* 0x3fd614840309cfe1 */
+    3.48457327308122011278e-01,  /* 0x3fd64d1ff635c1c5 */
+    3.51903825414964732676e-01,  /* 0x3fd685979f5fa6fd */
+    3.55341622416168290144e-01,  /* 0x3fd6bdeac9cbd76c */
+    3.58770670270572189509e-01,  /* 0x3fd6f61941e4def0 */
+    3.62190922004212156882e-01,  /* 0x3fd72e22d53aa2a9 */
+    3.65602331706966821034e-01,  /* 0x3fd7660752817501 */
+    3.69004854528964421068e-01,  /* 0x3fd79dc6899118d1 */
+    3.72398446676754202311e-01,  /* 0x3fd7d5604b63b3f7 */
+    3.75783065409248884237e-01,  /* 0x3fd80cd46a14b1d0 */
+    3.79158669033441808605e-01,  /* 0x3fd84422b8df95d7 */
+    3.82525216899905096124e-01,  /* 0x3fd87b4b0c1ebedb */
+    3.85882669398073752109e-01,  /* 0x3fd8b24d394a1b25 */
+    3.89230987951320717144e-01,  /* 0x3fd8e92916f5cde8 */
+    3.92570135011828580396e-01,  /* 0x3fd91fde7cd0c662 */
+    3.95900074055262896078e-01,  /* 0x3fd9566d43a34907 */
+    3.99220769575252543149e-01,  /* 0x3fd98cd5454d6b18 */
+    4.02532187077682512832e-01,  /* 0x3fd9c3165cc58107 */
+    4.05834293074804064450e-01,  /* 0x3fd9f93066168001 */
+    4.09127055079168300278e-01,  /* 0x3fda2f233e5e530b */
+    4.12410441597387267265e-01,  /* 0x3fda64eec3cc23fc */
+    4.15684422123729413467e-01,  /* 0x3fda9a92d59e98cf */
+    4.18948967133552840902e-01,  /* 0x3fdad00f5422058b */
+    4.22204048076583571270e-01,  /* 0x3fdb056420ae9343 */
+    4.25449637370042266227e-01,  /* 0x3fdb3a911da65c6c */
+    4.28685708391625730496e-01,  /* 0x3fdb6f962e737efb */
+    4.31912235472348193799e-01,  /* 0x3fdba473378624a5 */
+    4.35129193889246812521e-01,  /* 0x3fdbd9281e528191 */
+    4.38336559857957774877e-01,  /* 0x3fdc0db4c94ec9ef */
+    4.41534310525166673322e-01,  /* 0x3fdc42191ff11eb6 */
+    4.44722423960939305942e-01,  /* 0x3fdc76550aad71f8 */
+    4.47900879150937292206e-01,  /* 0x3fdcaa6872f3631b */
+    4.51069655988523443568e-01,  /* 0x3fdcde53432c1350 */
+    4.54228735266762495559e-01,  /* 0x3fdd121566b7f2ad */
+    4.57378098670320809571e-01,  /* 0x3fdd45aec9ec862b */
+    4.60517728767271039558e-01,  /* 0x3fdd791f5a1226f4 */
+    4.63647609000806093515e-01,  /* 0x3fddac670561bb4f */
+    4.66767723680866497560e-01,  /* 0x3fdddf85bb026974 */
+    4.69878057975686880265e-01,  /* 0x3fde127b6b0744af */
+    4.72978597903265574054e-01,  /* 0x3fde4548066cf51a */
+    4.76069330322761219421e-01,  /* 0x3fde77eb7f175a34 */
+    4.79150242925822533735e-01,  /* 0x3fdeaa65c7cf28c4 */
+    4.82221324227853687105e-01,  /* 0x3fdedcb6d43f8434 */
+    4.85282563559221225002e-01,  /* 0x3fdf0ede98f393cf */
+    4.88333951056405479729e-01,  /* 0x3fdf40dd0b541417 */
+    4.91375477653101910835e-01,  /* 0x3fdf72b221a4e495 */
+    4.94407135071275316562e-01,  /* 0x3fdfa45dd3029258 */
+    4.97428915812172245392e-01,  /* 0x3fdfd5e0175fdf83 */
+    5.00440813147294050189e-01,  /* 0x3fe0039c73c1a40b */
+    5.03442821109336358099e-01,  /* 0x3fe01c341e82422d */
+    5.06434934483096732549e-01,  /* 0x3fe034b709250488 */
+    5.09417148796356245022e-01,  /* 0x3fe04d25314342e5 */
+    5.12389460310737621107e-01,  /* 0x3fe0657e94db30cf */
+    5.15351866012543347040e-01,  /* 0x3fe07dc3324e9b38 */
+    5.18304363603577900044e-01,  /* 0x3fe095f30861a58f */
+    5.21246951491958210312e-01,  /* 0x3fe0ae0e1639866c */
+    5.24179628782913242802e-01,  /* 0x3fe0c6145b5b43da */
+    5.27102395269579471204e-01,  /* 0x3fe0de05d7aa6f7c */
+    5.30015251423793132268e-01,  /* 0x3fe0f5e28b67e295 */
+    5.32918198386882147055e-01,  /* 0x3fe10daa77307a0d */
+    5.35811237960463593311e-01,  /* 0x3fe1255d9bfbd2a8 */
+    5.38694372597246617929e-01,  /* 0x3fe13cfbfb1b056e */
+    5.41567605391844897333e-01,  /* 0x3fe1548596376469 */
+    5.44430940071603086672e-01,  /* 0x3fe16bfa6f5137e1 */
+    5.47284380987436924748e-01,  /* 0x3fe1835a88be7c13 */
+    5.50127933104692989907e-01,  /* 0x3fe19aa5e5299f99 */
+    5.52961601994028217888e-01,  /* 0x3fe1b1dc87904284 */
+    5.55785393822313511514e-01,  /* 0x3fe1c8fe7341f64f */
+    5.58599315343562330405e-01,  /* 0x3fe1e00babdefeb3 */
+    5.61403373889889367732e-01,  /* 0x3fe1f7043557138a */
+    5.64197577362497537656e-01,  /* 0x3fe20de813e823b1 */
+    5.66981934222700489912e-01,  /* 0x3fe224b74c1d192a */
+    5.69756453482978431069e-01,  /* 0x3fe23b71e2cc9e6a */
+    5.72521144698072359525e-01,  /* 0x3fe25217dd17e501 */
+    5.75276017956117824426e-01,  /* 0x3fe268a940696da6 */
+    5.78021083869819540801e-01,  /* 0x3fe27f261273d1b3 */
+    5.80756353567670302596e-01,  /* 0x3fe2958e59308e30 */
+    5.83481838685214859730e-01,  /* 0x3fe2abe21aded073 */
+    5.86197551356360535557e-01,  /* 0x3fe2c2215e024465 */
+    5.88903504204738026395e-01,  /* 0x3fe2d84c2961e48b */
+    5.91599710335111383941e-01,  /* 0x3fe2ee628406cbca */
+    5.94286183324841177367e-01,  /* 0x3fe30464753b090a */
+    5.96962937215401501234e-01,  /* 0x3fe31a52048874be */
+    5.99629986503951384336e-01,  /* 0x3fe3302b39b78856 */
+    6.02287346134964152178e-01,  /* 0x3fe345f01cce37bb */
+    6.04935031491913965951e-01,  /* 0x3fe35ba0b60eccce */
+    6.07573058389022313541e-01,  /* 0x3fe3713d0df6c503 */
+    6.10201443063065118722e-01,  /* 0x3fe386c52d3db11e */
+    6.12820202165241245673e-01,  /* 0x3fe39c391cd41719 */
+    6.15429352753104952356e-01,  /* 0x3fe3b198e5e2564a */
+    6.18028912282561737612e-01,  /* 0x3fe3c6e491c78dc4 */
+    6.20618898599929469384e-01,  /* 0x3fe3dc1c2a188504 */
+    6.23199329934065904268e-01,  /* 0x3fe3f13fb89e96f4 */
+    6.25770224888563042498e-01,  /* 0x3fe4064f47569f48 */
+    6.28331602434009650615e-01,  /* 0x3fe41b4ae06fea41 */
+    6.30883481900321840818e-01,  /* 0x3fe430328e4b26d5 */
+    6.33425882969144482537e-01,  /* 0x3fe445065b795b55 */
+    6.35958825666321447834e-01,  /* 0x3fe459c652badc7f */
+    6.38482330354437466191e-01,  /* 0x3fe46e727efe4715 */
+    6.40996417725432032775e-01,  /* 0x3fe4830aeb5f7bfd */
+    6.43501108793284370968e-01,  /* 0x3fe4978fa3269ee1 */
+    6.45996424886771558604e-01,  /* 0x3fe4ac00b1c71762 */
+    6.48482387642300484032e-01,  /* 0x3fe4c05e22de94e4 */
+    6.50959018996812410762e-01,  /* 0x3fe4d4a8023414e8 */
+    6.53426341180761927063e-01,  /* 0x3fe4e8de5bb6ec04 */
+    6.55884376711170835605e-01,  /* 0x3fe4fd013b7dd17e */
+    6.58333148384755983962e-01,  /* 0x3fe51110adc5ed81 */
+    6.60772679271132590273e-01,  /* 0x3fe5250cbef1e9fa */
+    6.63202992706093175102e-01,  /* 0x3fe538f57b89061e */
+    6.65624112284960989250e-01,  /* 0x3fe54ccaf0362c8f */
+    6.68036061856020157990e-01,  /* 0x3fe5608d29c70c34 */
+    6.70438865514021320458e-01,  /* 0x3fe5743c352b33b9 */
+    6.72832547593763097282e-01,  /* 0x3fe587d81f732fba */
+    6.75217132663749830535e-01,  /* 0x3fe59b60f5cfab9d */
+    6.77592645519925151909e-01,  /* 0x3fe5aed6c5909517 */
+    6.79959111179481823228e-01,  /* 0x3fe5c2399c244260 */
+    6.82316554874748071313e-01,  /* 0x3fe5d58987169b18 */
+    6.84665002047148862907e-01,  /* 0x3fe5e8c6941043cf */
+    6.87004478341244895212e-01,  /* 0x3fe5fbf0d0d5cc49 */
+    6.89335009598845749323e-01,  /* 0x3fe60f084b46e05e */
+    6.91656621853199760075e-01,  /* 0x3fe6220d115d7b8d */
+    6.93969341323259825138e-01,  /* 0x3fe634ff312d1f3b */
+    6.96273194408023488045e-01,  /* 0x3fe647deb8e20b8f */
+    6.98568207680949848637e-01,  /* 0x3fe65aabb6c07b02 */
+    7.00854407884450081312e-01,  /* 0x3fe66d663923e086 */
+    7.03131821924453670469e-01,  /* 0x3fe6800e4e7e2857 */
+    7.05400476865049030906e-01,  /* 0x3fe692a40556fb6a */
+    7.07660399923197958039e-01,  /* 0x3fe6a5276c4b0575 */
+    7.09911618463524796141e-01,  /* 0x3fe6b798920b3d98 */
+    7.12154159993178659249e-01,  /* 0x3fe6c9f7855c3198 */
+    7.14388052156768926793e-01,  /* 0x3fe6dc44551553ae */
+    7.16613322731374569052e-01,  /* 0x3fe6ee7f10204aef */
+    7.18829999621624415873e-01,  /* 0x3fe700a7c5784633 */
+    7.21038110854851588272e-01,  /* 0x3fe712be84295198 */
+    7.23237684576317874097e-01,  /* 0x3fe724c35b4fae7b */
+    7.25428749044510712274e-01,  /* 0x3fe736b65a172dff */
+    7.27611332626510676214e-01,  /* 0x3fe748978fba8e0f */
+    7.29785463793429123314e-01,  /* 0x3fe75a670b82d8d8 */
+    7.31951171115916565668e-01,  /* 0x3fe76c24dcc6c6c0 */
+    7.34108483259739652560e-01,  /* 0x3fe77dd112ea22c7 */
+    7.36257428981428097003e-01,  /* 0x3fe78f6bbd5d315e */
+    7.38398037123989547936e-01,  /* 0x3fe7a0f4eb9c19a2 */
+    7.40530336612692630105e-01,  /* 0x3fe7b26cad2e50fd */
+    7.42654356450917929600e-01,  /* 0x3fe7c3d311a6092b */
+    7.44770125716075148681e-01,  /* 0x3fe7d528289fa093 */
+    7.46877673555587429099e-01,  /* 0x3fe7e66c01c114fd */
+    7.48977029182941400620e-01,  /* 0x3fe7f79eacb97898 */
+    7.51068221873802288613e-01,  /* 0x3fe808c03940694a */
+    7.53151280962194302759e-01,  /* 0x3fe819d0b7158a4c */
+    7.55226235836744863583e-01,  /* 0x3fe82ad036000005 */
+    7.57293115936992444759e-01,  /* 0x3fe83bbec5cdee22 */
+    7.59351950749757920178e-01,  /* 0x3fe84c9c7653f7ea */
+    7.61402769805578416573e-01,  /* 0x3fe85d69576cc2c5 */
+    7.63445602675201784315e-01,  /* 0x3fe86e2578f87ae5 */
+    7.65480478966144461950e-01,  /* 0x3fe87ed0eadc5a2a */
+    7.67507428319308182552e-01,  /* 0x3fe88f6bbd023118 */
+    7.69526480405658186434e-01,  /* 0x3fe89ff5ff57f1f7 */
+    7.71537664922959498526e-01,  /* 0x3fe8b06fc1cf3dfe */
+    7.73541011592573490852e-01,  /* 0x3fe8c0d9145cf49d */
+    7.75536550156311621507e-01,  /* 0x3fe8d13206f8c4ca */
+    7.77524310373347682379e-01,  /* 0x3fe8e17aa99cc05d */
+    7.79504322017186335181e-01,  /* 0x3fe8f1b30c44f167 */
+    7.81476614872688268854e-01,  /* 0x3fe901db3eeef187 */
+    7.83441218733151756304e-01,  /* 0x3fe911f35199833b */
+    7.85398163397448278999e-01}; /* 0x3fe921fb54442d18 */
+
+  /* Some constants. */
+
+  static double pi = 3.1415926535897932e+00, /* 0x400921fb54442d18 */
+             piby2 = 1.5707963267948966e+00, /* 0x3ff921fb54442d18 */
+             piby4 = 7.8539816339744831e-01, /* 0x3fe921fb54442d18 */
+       three_piby4 = 2.3561944901923449e+00; /* 0x4002d97c7f3321d2 */
+
+  double u, v, vbyu, q, s, uu, r;
+  unsigned int swap_vu, index, xzero, yzero, xnan, ynan, xinf, yinf;
+  int xexp, yexp, diffexp;
+
+  double x = fx;
+  double y = fy;
+
+  /* Find properties of arguments x and y. */
+
+  unsigned long long ux, aux, xneg, uy, auy, yneg;
+
+  GET_BITS_DP64(x, ux);
+  GET_BITS_DP64(y, uy);
+  aux = ux & ~SIGNBIT_DP64;
+  auy = uy & ~SIGNBIT_DP64;
+  xexp = (int)((ux & EXPBITS_DP64) >> EXPSHIFTBITS_DP64);
+  yexp = (int)((uy & EXPBITS_DP64) >> EXPSHIFTBITS_DP64);
+  xneg = ux & SIGNBIT_DP64;
+  yneg = uy & SIGNBIT_DP64;
+  xzero = (aux == 0);
+  yzero = (auy == 0);
+  xnan = (aux > PINFBITPATT_DP64);
+  ynan = (auy > PINFBITPATT_DP64);
+  xinf = (aux == PINFBITPATT_DP64);
+  yinf = (auy == PINFBITPATT_DP64);
+
+  diffexp = yexp - xexp;
+
+  /* Special cases */
+
+  if (xnan)
+#ifdef WINDOWS
+    {
+      unsigned int ufx;
+      GET_BITS_SP32(fx, ufx);
+      return handle_errorf("atan2f", ufx|0x00400000, _DOMAIN, 0, EDOM, fx, fy);
+    }
+#else
+    return fx + fx; /* Raise invalid if it's a signalling NaN */
+#endif
+  else if (ynan)
+#ifdef WINDOWS
+    {
+      unsigned int ufy;
+      GET_BITS_SP32(fy, ufy);
+      return handle_errorf("atan2f", ufy|0x00400000, _DOMAIN, 0, EDOM, fx, fy);
+    }
+#else
+    return (float)(y + y); /* Raise invalid if it's a signalling NaN */
+#endif
+  else if (yzero)
+    { /* Zero y gives +-0 for positive x
+         and +-pi for negative x */
+#ifndef WINDOWS
+      if ((_LIB_VERSION == _SVID_) && xzero)
+        /* Sigh - _SVID_ defines atan2(0,0) as a domain error */
+        return retval_errno_edom(x, y);
+      else
+#endif
+      if (xneg)
+	{
+	  if (yneg) return valf_with_flags((float)-pi, AMD_F_INEXACT);
+          else return valf_with_flags((float)pi, AMD_F_INEXACT);
+	}
+      else return (float)y;
+    }
+  else if (xzero)
+    { /* Zero x gives +- pi/2
+         depending on sign of y */
+      if (yneg) return valf_with_flags((float)-piby2, AMD_F_INEXACT);
+      else valf_with_flags((float)piby2, AMD_F_INEXACT);
+    }
+
+  if (diffexp > 26)
+    { /* abs(y)/abs(x) > 2^26 => arctan(x/y)
+         is insignificant compared to piby2 */
+      if (yneg) return valf_with_flags((float)-piby2, AMD_F_INEXACT);
+      else return valf_with_flags((float)piby2, AMD_F_INEXACT);
+    }
+  else if (diffexp < -13 && (!xneg))
+    { /* x positive and dominant over y by a factor of 2^13.
+         In this case atan(y/x) is y/x to machine accuracy. */
+
+      if (diffexp < -150) /* Result underflows */
+        {
+          if (yneg)
+            return valf_with_flags(-0.0F, AMD_F_INEXACT | AMD_F_UNDERFLOW);
+          else
+            return valf_with_flags(0.0F, AMD_F_INEXACT | AMD_F_UNDERFLOW);
+        }
+      else
+        {
+          if (diffexp < -126)
+            {
+              /* Result will likely be denormalized */
+              y = scaleDouble_1(y, 100);
+              y /= x;
+              /* Now y is 2^100 times the true result. Scale it back down. */
+              GET_BITS_DP64(y, uy);
+	      scaleDownDouble(uy, 100, &uy);
+              PUT_BITS_DP64(uy, y);
+	      if ((uy & EXPBITS_DP64) == 0)
+		return valf_with_flags((float)y, AMD_F_INEXACT | AMD_F_UNDERFLOW);
+	      else
+		return (float)y;
+             }
+          else
+            return (float)(y / x);
+        }
+    }
+  else if (diffexp < -26 && xneg)
+    { /* abs(x)/abs(y) > 2^56 and x < 0 => arctan(y/x)
+         is insignificant compared to pi */
+    if (yneg) return valf_with_flags((float)-pi, AMD_F_INEXACT);
+    else return valf_with_flags((float)pi, AMD_F_INEXACT);
+    }
+  else if (yinf && xinf)
+    { /* If abs(x) and abs(y) are both infinity
+         return +-pi/4 or +- 3pi/4 according to
+         signs.  */
+    if (xneg)
+      {
+      if (yneg) return valf_with_flags((float)-three_piby4, AMD_F_INEXACT);
+      else return valf_with_flags((float)three_piby4, AMD_F_INEXACT);
+      }
+    else
+      {
+      if (yneg) return valf_with_flags((float)-piby4, AMD_F_INEXACT);
+      else return valf_with_flags((float)piby4, AMD_F_INEXACT);
+      }
+    }
+
+  /* General case: take absolute values of arguments */
+
+  u = x; v = y;
+  if (xneg) u = -x;
+  if (yneg) v = -y;
+
+  /* Swap u and v if necessary to obtain 0 < v < u. Compute v/u. */
+
+  swap_vu = (u < v);
+  if (swap_vu) { uu = u; u = v; v = uu; }
+  vbyu = v/u;
+
+  if (vbyu > 0.0625)
+    { /* General values of v/u. Use a look-up
+         table and series expansion. */
+
+      index = (int)(256*vbyu + 0.5);
+      r = (256*v-index*u)/(256*u+index*v);
+
+      /* Polynomial approximation to atan(vbyu) */
+
+      s = r*r;
+      q = atan_jby256[index-16] + r - r*s*0.33333333333224095522;
+    }
+  else if (vbyu < 1.e-4)
+    { /* v/u is small enough that atan(v/u) = v/u */
+      q = vbyu;
+    }
+  else /* vbyu <= 0.0625 */
+    {
+      /* Small values of v/u. Use a series expansion */
+
+      s  = vbyu*vbyu;
+      q = vbyu -
+	vbyu*s*(0.33333333333333170500 -
+		s*(0.19999999999393223405 -
+		   s*0.14285713561807169030));
+    }
+
+  /* Tidy-up according to which quadrant the arguments lie in */
+
+  if (swap_vu) {q = piby2 - q;}
+  if (xneg) {q = pi - q;}
+  if (yneg) q = - q;
+  return (float)q;
+}
+
+weak_alias (__atan2f, atan2f)
diff --git a/src/atanf.c b/src/atanf.c
new file mode 100644
index 0000000..567dd87
--- /dev/null
+++ b/src/atanf.c
@@ -0,0 +1,170 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#define USE_VALF_WITH_FLAGS
+#define USE_NAN_WITH_FLAGS
+#define USE_HANDLE_ERRORF
+#include "../inc/libm_inlines_amd.h"
+#undef USE_VALF_WITH_FLAGS
+#undef USE_NAN_WITH_FLAGS
+#undef USE_HANDLE_ERRORF
+
+#include "../inc/libm_errno_amd.h"
+
+#ifndef WINDOWS
+/* Deal with errno for out-of-range argument */
+static inline float retval_errno_edom(float x)
+{
+  struct exception exc;
+  exc.arg1 = (float)x;
+  exc.arg2 = (float)x;
+  exc.name = (char *)"atanf";
+  exc.type = DOMAIN;
+  if (_LIB_VERSION == _SVID_)
+    exc.retval = HUGE;
+  else
+    exc.retval = nan_with_flags(AMD_F_INVALID);
+  if (_LIB_VERSION == _POSIX_)
+    __set_errno(EDOM);
+  else if (!matherr(&exc))
+    {
+      if(_LIB_VERSION == _SVID_)
+        (void)fputs("atanf: DOMAIN error\n", stderr);
+    __set_errno(EDOM);
+    }
+  return exc.retval;
+}
+#endif
+
+#ifdef WINDOWS
+#pragma function(atanf)
+#endif
+
+float FN_PROTOTYPE(atanf)(float fx)
+{
+
+  /* Some constants and split constants. */
+
+  static double piby2 = 1.5707963267948966e+00; /* 0x3ff921fb54442d18 */
+
+  double c, v, s, q, z;
+  unsigned int xnan;
+
+  double x = fx;
+
+  /* Find properties of argument fx. */
+
+  unsigned long long ux, aux, xneg;
+
+  GET_BITS_DP64(x, ux);
+  aux = ux & ~SIGNBIT_DP64;
+  xneg = ux & SIGNBIT_DP64;
+
+  v = x;
+  if (xneg) v = -x;
+
+  /* Argument reduction to range [-7/16,7/16] */
+
+  if (aux < 0x3ec0000000000000) /* v < 2.0^(-19) */
+    {
+      /* x is a good approximation to atan(x) */
+      if (aux == 0x0000000000000000)
+        return fx;
+      else
+        return valf_with_flags(fx, AMD_F_INEXACT);
+    }
+  else if (aux < 0x3fdc000000000000) /* v < 7./16. */
+    {
+      x = v;
+      c = 0.0;
+    }
+  else if (aux < 0x3fe6000000000000) /* v < 11./16. */
+    {
+      x = (2.0*v-1.0)/(2.0+v);
+      /* c = arctan(0.5) */
+      c = 4.63647609000806093515e-01; /* 0x3fddac670561bb4f */
+    }
+  else if (aux < 0x3ff3000000000000) /* v < 19./16. */
+    {
+      x = (v-1.0)/(1.0+v);
+      /* c = arctan(1.) */
+      c = 7.85398163397448278999e-01; /* 0x3fe921fb54442d18 */
+    }
+  else if (aux < 0x4003800000000000) /* v < 39./16. */
+    {
+      x = (v-1.5)/(1.0+1.5*v);
+      /* c = arctan(1.5) */
+      c = 9.82793723247329054082e-01; /* 0x3fef730bd281f69b */
+    }
+  else
+    {
+
+      xnan = (aux > PINFBITPATT_DP64);
+
+      if (xnan)
+        {
+          /* x is NaN */
+#ifdef WINDOWS
+          unsigned int uhx;
+          GET_BITS_SP32(fx, uhx);
+          return handle_errorf("atanf", uhx|0x00400000, _DOMAIN,
+                               0, EDOM, fx, 0.0F);
+#else
+          return x + x; /* Raise invalid if it's a signalling NaN */
+#endif
+        }
+      else if (aux > 0x4190000000000000)
+	{ /* abs(x) > 2^26 => arctan(1/x) is
+	     insignificant compared to piby2 */
+	  if (xneg)
+            return valf_with_flags((float)-piby2, AMD_F_INEXACT);
+	  else
+            return valf_with_flags((float)piby2, AMD_F_INEXACT);
+	}
+
+      x = -1.0/v;
+      /* c = arctan(infinity) */
+      c = 1.57079632679489655800e+00; /* 0x3ff921fb54442d18 */
+    }
+
+  /* Core approximation: Remez(2,2) on [-7/16,7/16] */
+
+  s = x*x;
+  q = x*s*
+    (0.296528598819239217902158651186e0 +
+     (0.192324546402108583211697690500e0 +
+       0.470677934286149214138357545549e-2*s)*s)/
+    (0.889585796862432286486651434570e0 +
+     (0.111072499995399550138837673349e1 +
+       0.299309699959659728404442796915e0*s)*s);
+
+  z = c - (q - x);
+
+  if (xneg) z = -z;
+  return (float)z;
+}
+
+weak_alias (__atanf, atanf)
diff --git a/src/atanh.c b/src/atanh.c
new file mode 100644
index 0000000..5815ced
--- /dev/null
+++ b/src/atanh.c
@@ -0,0 +1,193 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#define USE_NAN_WITH_FLAGS
+#define USE_VAL_WITH_FLAGS
+#define USE_INFINITY_WITH_FLAGS
+#define USE_HANDLE_ERROR
+#include "../inc/libm_inlines_amd.h"
+#undef USE_NAN_WITH_FLAGS
+#undef USE_VAL_WITH_FLAGS
+#undef USE_INFINITY_WITH_FLAGS
+#undef USE_HANDLE_ERROR
+
+#include "../inc/libm_errno_amd.h"
+
+#ifndef WINDOWS
+/* Deal with errno for out-of-range argument */
+static inline double retval_errno_edom(double x, double retval)
+{
+  struct exception exc;
+  exc.arg1 = x;
+  exc.arg2 = x;
+  exc.type = DOMAIN;
+  exc.name = (char *)"atanh";
+  if (_LIB_VERSION == _SVID_)
+    exc.retval = -HUGE;
+  else
+    exc.retval = retval;
+  if (_LIB_VERSION == _POSIX_)
+    __set_errno(EDOM);
+  else if (!matherr(&exc))
+    {
+      if(_LIB_VERSION == _SVID_)
+        (void)fputs("atanh: DOMAIN error\n", stderr);
+    __set_errno(EDOM);
+    }
+  return exc.retval;
+}
+#endif
+
+#undef _FUNCNAME
+#define _FUNCNAME "atanh"
+double FN_PROTOTYPE(atanh)(double x)
+{
+
+  unsigned long long ux, ax;
+  double r, absx, t, poly;
+
+
+  GET_BITS_DP64(x, ux);
+  ax = ux & ~SIGNBIT_DP64;
+  PUT_BITS_DP64(ax, absx);
+
+  if ((ux & EXPBITS_DP64) == EXPBITS_DP64)
+    {
+      /* x is either NaN or infinity */
+      if (ux & MANTBITS_DP64)
+        {
+          /* x is NaN */
+#ifdef WINDOWS
+          return handle_error(_FUNCNAME, ux|0x0008000000000000, _DOMAIN,
+                              AMD_F_INVALID, EDOM, x, 0.0);
+#else
+          return x + x; /* Raise invalid if it is a signalling NaN */
+#endif
+        }
+      else
+        {
+          /* x is infinity; return a NaN */
+#ifdef WINDOWS
+          return handle_error(_FUNCNAME, INDEFBITPATT_DP64, _DOMAIN,
+                              AMD_F_INVALID, EDOM, x, 0.0);
+#else
+          return retval_errno_edom(x,nan_with_flags(AMD_F_INVALID));
+#endif
+        }
+    }
+  else if (ax >= 0x3ff0000000000000)
+    {
+      if (ax > 0x3ff0000000000000)
+        {
+          /* abs(x) > 1.0; return NaN */
+#ifdef WINDOWS
+          return handle_error(_FUNCNAME, INDEFBITPATT_DP64, _DOMAIN,
+                              AMD_F_INVALID, EDOM, x, 0.0);
+#else
+          return retval_errno_edom(x,nan_with_flags(AMD_F_INVALID));
+#endif
+        }
+      else if (ux == 0x3ff0000000000000)
+        {
+          /* x = +1.0; return infinity with the same sign as x
+             and set the divbyzero status flag */
+#ifdef WINDOWS
+          return handle_error(_FUNCNAME, PINFBITPATT_DP64, _DOMAIN,
+                              AMD_F_INVALID, EDOM, x, 0.0);
+#else
+          return retval_errno_edom(x,infinity_with_flags(AMD_F_DIVBYZERO));
+#endif
+        }
+      else
+        {
+          /* x = -1.0; return infinity with the same sign as x */
+#ifdef WINDOWS
+          return handle_error(_FUNCNAME, NINFBITPATT_DP64, _DOMAIN,
+                              AMD_F_INVALID, EDOM, x, 0.0);
+#else
+          return retval_errno_edom(x,-infinity_with_flags(AMD_F_DIVBYZERO));
+#endif
+        }
+    }
+
+
+  if (ax < 0x3e30000000000000)
+    {
+      if (ax == 0x0000000000000000)
+        {
+          /* x is +/-zero. Return the same zero. */
+          return x;
+        }
+      else
+        {
+          /* Arguments smaller than 2^(-28) in magnitude are
+             approximated by atanh(x) = x, raising inexact flag. */
+          return val_with_flags(x, AMD_F_INEXACT);
+        }
+    }
+  else
+    {
+      if (ax < 0x3fe0000000000000)
+        {
+          /* Arguments up to 0.5 in magnitude are
+             approximated by a [5,5] minimax polynomial */
+          t = x*x;
+          poly =
+            (0.47482573589747356373e0 +
+             (-0.11028356797846341457e1 +
+              (0.88468142536501647470e0 +
+               (-0.28180210961780814148e0 +
+                (0.28728638600548514553e-1 -
+                 0.10468158892753136958e-3 * t) * t) * t) * t) * t) /
+            (0.14244772076924206909e1 +
+             (-0.41631933639693546274e1 +
+              (0.45414700626084508355e1 +
+               (-0.22608883748988489342e1 +
+                (0.49561196555503101989e0 -
+                 0.35861554370169537512e-1 * t) * t) * t) * t) * t);
+          return x + x*t*poly;
+        }
+      else
+        {
+          /* abs(x) >= 0.5 */
+          /* Note that
+               atanh(x) = 0.5 * ln((1+x)/(1-x))
+             (see Abramowitz and Stegun 4.6.22).
+             For greater accuracy we use the variant formula
+             atanh(x) = log(1 + 2x/(1-x)) = log1p(2x/(1-x)).
+          */
+          r = (2.0 * absx) / (1.0 - absx);
+          r = 0.5 * FN_PROTOTYPE(log1p)(r);
+          if (ux & SIGNBIT_DP64)
+            /* Argument x is negative */
+            return -r;
+          else
+            return r;
+        }
+    }
+}
+
+weak_alias (__atanh, atanh)
diff --git a/src/atanhf.c b/src/atanhf.c
new file mode 100644
index 0000000..38692b4
--- /dev/null
+++ b/src/atanhf.c
@@ -0,0 +1,194 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#include <stdio.h>
+
+#define USE_NANF_WITH_FLAGS
+#define USE_VALF_WITH_FLAGS
+#define USE_INFINITYF_WITH_FLAGS
+#define USE_HANDLE_ERRORF
+#include "../inc/libm_inlines_amd.h"
+#undef USE_NANF_WITH_FLAGS
+#undef USE_VALF_WITH_FLAGS
+#undef USE_INFINITYF_WITH_FLAGS
+#undef USE_HANDLE_ERRORF
+
+#include "../inc/libm_errno_amd.h"
+
+#ifndef WINDOWS
+/* Deal with errno for out-of-range argument */
+static inline float retval_errno_edom(float x, float retval)
+{
+  struct exception exc;
+  exc.arg1 = (double)x;
+  exc.arg2 = (double)x;
+  exc.type = DOMAIN;
+  exc.name = (char *)"atanhf";
+  if (_LIB_VERSION == _SVID_)
+    exc.retval = -HUGE;
+  else
+    exc.retval = (double)retval;
+  if (_LIB_VERSION == _POSIX_)
+    __set_errno(EDOM);
+  else if (!matherr(&exc))
+    {
+      if(_LIB_VERSION == _SVID_)
+        (void)fputs("atanhf: DOMAIN error\n", stderr);
+    __set_errno(EDOM);
+    }
+  return exc.retval;
+}
+#endif
+
+#undef _FUNCNAME
+#define _FUNCNAME "atanhf"
+float FN_PROTOTYPE(atanhf)(float x)
+{
+
+  double dx;
+  unsigned int ux, ax;
+  double r, t, poly;
+
+  GET_BITS_SP32(x, ux);
+  ax = ux & ~SIGNBIT_SP32;
+
+  if ((ux & EXPBITS_SP32) == EXPBITS_SP32)
+    {
+      /* x is either NaN or infinity */
+      if (ux & MANTBITS_SP32)
+        {
+          /* x is NaN */
+#ifdef WINDOWS
+          return handle_errorf(_FUNCNAME, ux|0x00400000, _DOMAIN,
+                              0, EDOM, x, 0.0F);
+#else
+          return x + x; /* Raise invalid if it is a signalling NaN */
+#endif
+        }
+      else
+        {
+          /* x is infinity; return a NaN */
+#ifdef WINDOWS
+          return handle_errorf(_FUNCNAME, INDEFBITPATT_SP32, _DOMAIN,
+                               AMD_F_INVALID, EDOM, x, 0.0F);
+#else
+          return retval_errno_edom(x,nanf_with_flags(AMD_F_INVALID));
+#endif
+        }
+    }
+  else if (ax >= 0x3f800000)
+    {
+      if (ax > 0x3f800000)
+        {
+          /* abs(x) > 1.0; return NaN */
+#ifdef WINDOWS
+          return handle_errorf(_FUNCNAME, INDEFBITPATT_SP32, _DOMAIN,
+                               AMD_F_INVALID, EDOM, x, 0.0F);
+#else
+          return retval_errno_edom(x,nanf_with_flags(AMD_F_INVALID));
+#endif
+        }
+      else if (ux == 0x3f800000)
+        {
+          /* x = +1.0; return infinity with the same sign as x
+             and set the divbyzero status flag */
+#ifdef WINDOWS
+          return handle_errorf(_FUNCNAME, PINFBITPATT_SP32, _DOMAIN,
+                               AMD_F_INVALID, EDOM, x, 0.0F);
+#else
+          return retval_errno_edom(x,infinityf_with_flags(AMD_F_DIVBYZERO));
+#endif
+        }
+      else
+        {
+          /* x = -1.0; return infinity with the same sign as x */
+#ifdef WINDOWS
+          return handle_errorf(_FUNCNAME, NINFBITPATT_SP32, _DOMAIN,
+                               AMD_F_INVALID, EDOM, x, 0.0F);
+#else
+          return retval_errno_edom(x,-infinityf_with_flags(AMD_F_DIVBYZERO));
+#endif
+        }
+    }
+
+  if (ax < 0x39000000)
+    {
+      if (ax == 0x00000000)
+        {
+          /* x is +/-zero. Return the same zero. */
+          return x;
+        }
+      else
+        {
+          /* Arguments smaller than 2^(-13) in magnitude are
+             approximated by atanhf(x) = x, raising inexact flag. */
+          return valf_with_flags(x, AMD_F_INEXACT);
+        }
+    }
+  else
+    {
+      dx = x;
+      if (ax < 0x3f000000)
+        {
+          /* Arguments up to 0.5 in magnitude are
+             approximated by a [2,2] minimax polynomial */
+          t = dx*dx;
+          poly =
+            (0.39453629046e0 +
+           (-0.28120347286e0 +
+             0.92834212715e-2 * t) * t) /
+            (0.11836088638e1 + 
+           (-0.15537744551e1 +
+             0.45281890445e0 * t) * t);
+          return (float)(dx + dx*t*poly);
+        }
+      else
+        {
+          /* abs(x) >= 0.5 */
+          /* Note that
+               atanhf(x) = 0.5 * ln((1+x)/(1-x))
+             (see Abramowitz and Stegun 4.6.22).
+             For greater accuracy we use the variant formula
+             atanhf(x) = log(1 + 2x/(1-x)) = log1p(2x/(1-x)).
+          */
+          if (ux & SIGNBIT_SP32)
+            {
+              /* Argument x is negative */
+              r = (-2.0 * dx) / (1.0 + dx);
+              r = 0.5 * FN_PROTOTYPE(log1p)(r);
+              return (float)-r;
+            }
+          else
+            {
+              r = (2.0 * dx) / (1.0 - dx);
+              r = 0.5 * FN_PROTOTYPE(log1p)(r);
+              return (float)r;
+            }
+        }
+    }
+}
+
+weak_alias (__atanhf, atanhf)
diff --git a/src/ceil.c b/src/ceil.c
new file mode 100644
index 0000000..94ef21d
--- /dev/null
+++ b/src/ceil.c
@@ -0,0 +1,104 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#ifdef WINDOWS
+#include "../inc/libm_errno_amd.h"
+#define USE_HANDLE_ERROR
+#include "../inc/libm_inlines_amd.h"
+#undef USE_HANDLE_ERROR
+#endif
+
+#ifdef WINDOWS
+#pragma function(ceil)
+#endif
+
+double FN_PROTOTYPE(ceil)(double x)
+{
+  double r;
+  long long rexp, xneg;
+  unsigned long long ux, ax, ur, mask;
+
+  GET_BITS_DP64(x, ux);
+  /*ax is |x|*/
+  ax = ux & (~SIGNBIT_DP64);
+  /*xneg stores the sign of the input x*/
+  xneg = (ux != ax);
+  /*The range is divided into 
+    > 2^53. ceil will either the number itself or Nan
+            always returns a QNan. Raises exception if input is a SNan
+    < 1.0   If 0.0 then return with the appropriate sign
+            If input is less than -0.0 and greater than -1.0 then return -0.0
+            If input is greater than 0.0 and less than 1.0 then return 1.0
+    1.0 < |x| < 2^53 
+            appropriately check the exponent and set the return Value by shifting
+            */
+  if (ax >= 0x4340000000000000) /* abs(x) > 2^53*/
+    {
+      /* abs(x) is either NaN, infinity, or >= 2^53 */
+      if (ax > 0x7ff0000000000000)
+        /* x is NaN */
+#ifdef WINDOWS
+        return handle_error("ceil", ux|0x0008000000000000, _DOMAIN, 0,
+                            EDOM, x, 0.0);
+#else
+        return x + x; /* Raise invalid if it is a signalling NaN */
+#endif
+      else
+        return x;
+    }
+  else if (ax < 0x3ff0000000000000) /* abs(x) < 1.0 */
+    {
+      if (ax == 0x0000000000000000)
+        /* x is +zero or -zero; return the same zero */
+          return x;
+      else if (xneg) /* x < 0.0; return -0.0 */
+        {
+          PUT_BITS_DP64(0x8000000000000000, r);
+          return r;
+        }
+      else
+        return 1.0;
+    }
+  else
+    {
+      /*Get the exponent for the floating point number. Should be between 0 and 53*/
+      rexp = ((ux & EXPBITS_DP64) >> EXPSHIFTBITS_DP64) - EXPBIAS_DP64;
+      /* Mask out the bits of r that we don't want */
+      mask = 1;
+      mask = (mask << (EXPSHIFTBITS_DP64 - rexp)) - 1;
+      /*Keeps the exponent part and the required mantissa.*/
+      ur = (ux & ~mask);
+      PUT_BITS_DP64(ur, r);
+      if (xneg || (ur == ux))
+        return r;
+      else
+        /* We threw some bits away and x was positive */
+        return r + 1.0;
+    }
+
+}
+
+weak_alias (__ceil, ceil)
diff --git a/src/ceilf.c b/src/ceilf.c
new file mode 100644
index 0000000..56d0c37
--- /dev/null
+++ b/src/ceilf.c
@@ -0,0 +1,97 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#ifdef WINDOWS
+#include "../inc/libm_errno_amd.h"
+#define USE_HANDLE_ERRORF
+#include "../inc/libm_inlines_amd.h"
+#undef USE_HANDLE_ERRORF
+#endif
+
+#ifdef WINDOWS
+#pragma function(ceilf)
+#endif
+
+float FN_PROTOTYPE(ceilf)(float x)
+{
+  float r;
+  int rexp, xneg;
+  unsigned int ux, ax, ur, mask;
+
+  GET_BITS_SP32(x, ux);
+  /*ax is |x|*/
+  ax = ux & (~SIGNBIT_SP32);
+  /*xneg stores the sign of the input x*/
+  xneg = (ux != ax);
+  /*The range is divided into 
+    > 2^24. ceil will either the number itself or Nan
+            always returns a QNan. Raises exception if input is a SNan
+    < 1.0   If 0.0 then return with the appropriate sign
+            If input is less than -0.0 and greater than -1.0 then return -0.0
+            If input is greater than 0.0 and less than 1.0 then return 1.0
+    1.0 < |x| < 2^24 
+            appropriately check the exponent and set the return Value by shifting
+            */
+  if (ax >= 0x4b800000) /* abs(x) > 2^24*/
+    {
+      /* abs(x) is either NaN, infinity, or >= 2^24 */
+      if (ax > 0x7f800000)
+        /* x is NaN */
+#ifdef WINDOWS
+        return handle_errorf("ceilf", ux, _DOMAIN, 0, EDOM, x, 0.0F);
+#else
+        return x + x; /* Raise invalid if it is a signalling NaN */
+#endif
+      else
+        return x;
+    }
+  else if (ax < 0x3f800000) /* abs(x) < 1.0 */
+    {
+      if (ax == 0x00000000)
+        /* x is +zero or -zero; return the same zero */
+        return x;
+      else if (xneg) /* x < 0.0 */
+        return -0.0F;
+      else
+        return 1.0F;
+    }
+  else
+    {
+      rexp = ((ux & EXPBITS_SP32) >> EXPSHIFTBITS_SP32) - EXPBIAS_SP32;
+      /* Mask out the bits of r that we don't want */
+      mask = (1 << (EXPSHIFTBITS_SP32 - rexp)) - 1;
+      /*Keeps the exponent part and the required mantissa.*/
+      ur = (ux & ~mask);
+      PUT_BITS_SP32(ur, r);
+
+      if (xneg || (ux == ur)) return r;
+      else
+        /* We threw some bits away and x was positive */
+        return r + 1.0F;
+    }
+}
+
+weak_alias (__ceilf, ceilf)
diff --git a/src/cosh.c b/src/cosh.c
new file mode 100644
index 0000000..6f8734b
--- /dev/null
+++ b/src/cosh.c
@@ -0,0 +1,359 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#define USE_SPLITEXP
+#define USE_SCALEDOUBLE_1
+#define USE_SCALEDOUBLE_2
+#define USE_INFINITY_WITH_FLAGS
+#define USE_VAL_WITH_FLAGS
+#define USE_HANDLE_ERROR
+#include "../inc/libm_inlines_amd.h"
+#undef USE_HANDLE_ERROR
+#undef USE_SPLITEXP
+#undef USE_SCALEDOUBLE_1
+#undef USE_SCALEDOUBLE_2
+#undef USE_INFINITY_WITH_FLAGS
+#undef USE_VAL_WITH_FLAGS
+
+#include "../inc/libm_errno_amd.h"
+#ifndef WINDOWS
+/* Deal with errno for out-of-range result */
+static inline double retval_errno_erange(double x)
+{
+  struct exception exc;
+  exc.arg1 = x;
+  exc.arg2 = x;
+  exc.type = OVERFLOW;
+  exc.name = (char *)"cosh";
+  if (_LIB_VERSION == _SVID_)
+    {
+        exc.retval = HUGE;
+    }
+  else
+    {
+        exc.retval = infinity_with_flags(AMD_F_OVERFLOW);
+    }
+  if (_LIB_VERSION == _POSIX_)
+    __set_errno(ERANGE);
+  else if (!matherr(&exc))
+    __set_errno(ERANGE);
+  return exc.retval;
+}
+#endif
+
+double FN_PROTOTYPE(cosh)(double x)
+{
+  /*
+    Derived from sinh subroutine
+    
+    After dealing with special cases the computation is split into
+    regions as follows:
+
+    abs(x) >= max_cosh_arg:
+    cosh(x) = sign(x)*Inf
+
+    abs(x) >= small_threshold:
+    cosh(x) = sign(x)*exp(abs(x))/2 computed using the
+    splitexp and scaleDouble functions as for exp_amd().
+
+    abs(x) < small_threshold:
+    compute p = exp(y) - 1 and then z = 0.5*(p+(p/(p+1.0)))
+    cosh(x) is then sign(x)*z.                             */
+
+  static const double
+    max_cosh_arg = 7.10475860073943977113e+02, /* 0x408633ce8fb9f87e */
+    thirtytwo_by_log2 = 4.61662413084468283841e+01, /* 0x40471547652b82fe */
+    log2_by_32_lead = 2.16608493356034159660e-02, /* 0x3f962e42fe000000 */
+    log2_by_32_tail = 5.68948749532545630390e-11, /* 0x3dcf473de6af278e */
+//    small_threshold = 8*BASEDIGITS_DP64*0.30102999566398119521373889;
+    small_threshold = 20.0;
+  /* (8*BASEDIGITS_DP64*log10of2) ' exp(-x) insignificant c.f. exp(x) */
+
+  /* Lead and tail tabulated values of sinh(i) and cosh(i) 
+     for i = 0,...,36. The lead part has 26 leading bits. */
+
+  static const double sinh_lead[   37] = {
+    0.00000000000000000000e+00,  /* 0x0000000000000000 */
+    1.17520117759704589844e+00,  /* 0x3ff2cd9fc0000000 */
+    3.62686038017272949219e+00,  /* 0x400d03cf60000000 */
+    1.00178747177124023438e+01,  /* 0x40240926e0000000 */
+    2.72899169921875000000e+01,  /* 0x403b4a3800000000 */
+    7.42032089233398437500e+01,  /* 0x40528d0160000000 */
+    2.01713153839111328125e+02,  /* 0x406936d228000000 */
+    5.48316116333007812500e+02,  /* 0x4081228768000000 */
+    1.49047882080078125000e+03,  /* 0x409749ea50000000 */
+    4.05154187011718750000e+03,  /* 0x40afa71570000000 */
+    1.10132326660156250000e+04,  /* 0x40c5829dc8000000 */
+    2.99370708007812500000e+04,  /* 0x40dd3c4488000000 */
+    8.13773945312500000000e+04,  /* 0x40f3de1650000000 */
+    2.21206695312500000000e+05,  /* 0x410b00b590000000 */
+    6.01302140625000000000e+05,  /* 0x412259ac48000000 */
+    1.63450865625000000000e+06,  /* 0x4138f0cca8000000 */
+    4.44305525000000000000e+06,  /* 0x4150f2ebd0000000 */
+    1.20774762500000000000e+07,  /* 0x4167093488000000 */
+    3.28299845000000000000e+07,  /* 0x417f4f2208000000 */
+    8.92411500000000000000e+07,  /* 0x419546d8f8000000 */
+    2.42582596000000000000e+08,  /* 0x41aceb0888000000 */
+    6.59407856000000000000e+08,  /* 0x41c3a6e1f8000000 */
+    1.79245641600000000000e+09,  /* 0x41dab5adb8000000 */
+    4.87240166400000000000e+09,  /* 0x41f226af30000000 */
+    1.32445608960000000000e+10,  /* 0x4208ab7fb0000000 */
+    3.60024494080000000000e+10,  /* 0x4220c3d390000000 */
+    9.78648043520000000000e+10,  /* 0x4236c93268000000 */
+    2.66024116224000000000e+11,  /* 0x424ef822f0000000 */
+    7.23128516608000000000e+11,  /* 0x42650bba30000000 */
+    1.96566712320000000000e+12,  /* 0x427c9aae40000000 */
+    5.34323724288000000000e+12,  /* 0x4293704708000000 */
+    1.45244246507520000000e+13,  /* 0x42aa6b7658000000 */
+    3.94814795284480000000e+13,  /* 0x42c1f43fc8000000 */
+    1.07321789251584000000e+14,  /* 0x42d866f348000000 */
+    2.91730863685632000000e+14,  /* 0x42f0953e28000000 */
+    7.93006722514944000000e+14,  /* 0x430689e220000000 */
+    2.15561576592179200000e+15}; /* 0x431ea215a0000000 */
+
+  static const double sinh_tail[   37] = {
+    0.00000000000000000000e+00,  /* 0x0000000000000000 */
+    1.60467555584448807892e-08,  /* 0x3e513ae6096a0092 */
+    2.76742892754807136947e-08,  /* 0x3e5db70cfb79a640 */
+    2.09697499555224576530e-07,  /* 0x3e8c2526b66dc067 */
+    2.04940252448908240062e-07,  /* 0x3e8b81b18647f380 */
+    1.65444891522700935932e-06,  /* 0x3ebbc1cdd1e1eb08 */
+    3.53116789999998198721e-06,  /* 0x3ecd9f201534fb09 */
+    6.94023870987375490695e-06,  /* 0x3edd1c064a4e9954 */
+    4.98876893611587449271e-06,  /* 0x3ed4eca65d06ea74 */
+    3.19656024605152215752e-05,  /* 0x3f00c259bcc0ecc5 */
+    2.08687768377236501204e-04,  /* 0x3f2b5a6647cf9016 */
+    4.84668088325403796299e-05,  /* 0x3f09691adefb0870 */
+    1.17517985422733832468e-03,  /* 0x3f53410fc29cde38 */
+    6.90830086959560562415e-04,  /* 0x3f46a31a50b6fb3c */
+    1.45697262451506548420e-03,  /* 0x3f57defc71805c40 */
+    2.99859023684906737806e-02,  /* 0x3f9eb49fd80e0bab */
+    1.02538800507941396667e-02,  /* 0x3f84fffc7bcd5920 */
+    1.26787628407699110022e-01,  /* 0x3fc03a93b6c63435 */
+    6.86652479544033744752e-02,  /* 0x3fb1940bb255fd1c */
+    4.81593627621056619148e-01,  /* 0x3fded26e14260b50 */
+    1.70489513795397629181e+00,  /* 0x3ffb47401fc9f2a2 */
+    1.12416073482258713767e+01,  /* 0x40267bb3f55634f1 */
+    7.06579578070110514432e+00,  /* 0x401c435ff8194ddc */
+    5.91244512999659974639e+01,  /* 0x404d8fee052ba63a */
+    1.68921736147050694399e+02,  /* 0x40651d7edccde3f6 */
+    2.60692936262073658327e+02,  /* 0x40704b1644557d1a */
+    3.62419382134885609048e+02,  /* 0x4076a6b5ca0a9dc4 */
+    4.07689930834187271103e+03,  /* 0x40afd9cc72249aba */
+    1.55377375868385224749e+04,  /* 0x40ce58de693edab5 */
+    2.53720210371943067003e+04,  /* 0x40d8c70158ac6363 */
+    4.78822310734952334315e+04,  /* 0x40e7614764f43e20 */
+    1.81871712615542812273e+05,  /* 0x4106337db36fc718 */
+    5.62892347580489004031e+05,  /* 0x41212d98b1f611e2 */
+    6.41374032312148716301e+05,  /* 0x412392bc108b37cc */
+    7.57809544070145115256e+06,  /* 0x415ce87bdc3473dc */
+    3.64177136406482197344e+06,  /* 0x414bc8d5ae99ad14 */
+    7.63580561355670914054e+06}; /* 0x415d20d76744835c */
+
+  static const double cosh_lead[   37] = {
+    1.00000000000000000000e+00,  /* 0x3ff0000000000000 */
+    1.54308062791824340820e+00,  /* 0x3ff8b07550000000 */
+    3.76219564676284790039e+00,  /* 0x400e18fa08000000 */
+    1.00676617622375488281e+01,  /* 0x402422a490000000 */
+    2.73082327842712402344e+01,  /* 0x403b4ee858000000 */
+    7.42099475860595703125e+01,  /* 0x40528d6fc8000000 */
+    2.01715633392333984375e+02,  /* 0x406936e678000000 */
+    5.48317031860351562500e+02,  /* 0x4081228948000000 */
+    1.49047915649414062500e+03,  /* 0x409749eaa8000000 */
+    4.05154199218750000000e+03,  /* 0x40afa71580000000 */
+    1.10132329101562500000e+04,  /* 0x40c5829dd0000000 */
+    2.99370708007812500000e+04,  /* 0x40dd3c4488000000 */
+    8.13773945312500000000e+04,  /* 0x40f3de1650000000 */
+    2.21206695312500000000e+05,  /* 0x410b00b590000000 */
+    6.01302140625000000000e+05,  /* 0x412259ac48000000 */
+    1.63450865625000000000e+06,  /* 0x4138f0cca8000000 */
+    4.44305525000000000000e+06,  /* 0x4150f2ebd0000000 */
+    1.20774762500000000000e+07,  /* 0x4167093488000000 */
+    3.28299845000000000000e+07,  /* 0x417f4f2208000000 */
+    8.92411500000000000000e+07,  /* 0x419546d8f8000000 */
+    2.42582596000000000000e+08,  /* 0x41aceb0888000000 */
+    6.59407856000000000000e+08,  /* 0x41c3a6e1f8000000 */
+    1.79245641600000000000e+09,  /* 0x41dab5adb8000000 */
+    4.87240166400000000000e+09,  /* 0x41f226af30000000 */
+    1.32445608960000000000e+10,  /* 0x4208ab7fb0000000 */
+    3.60024494080000000000e+10,  /* 0x4220c3d390000000 */
+    9.78648043520000000000e+10,  /* 0x4236c93268000000 */
+    2.66024116224000000000e+11,  /* 0x424ef822f0000000 */
+    7.23128516608000000000e+11,  /* 0x42650bba30000000 */
+    1.96566712320000000000e+12,  /* 0x427c9aae40000000 */
+    5.34323724288000000000e+12,  /* 0x4293704708000000 */
+    1.45244246507520000000e+13,  /* 0x42aa6b7658000000 */
+    3.94814795284480000000e+13,  /* 0x42c1f43fc8000000 */
+    1.07321789251584000000e+14,  /* 0x42d866f348000000 */
+    2.91730863685632000000e+14,  /* 0x42f0953e28000000 */
+    7.93006722514944000000e+14,  /* 0x430689e220000000 */
+    2.15561576592179200000e+15}; /* 0x431ea215a0000000 */
+
+  static const double cosh_tail[   37] = {
+    0.00000000000000000000e+00,  /* 0x0000000000000000 */
+    6.89700037027478056904e-09,  /* 0x3e3d9f5504c2bd28 */
+    4.43207835591715833630e-08,  /* 0x3e67cb66f0a4c9fd */
+    2.33540217013828929694e-07,  /* 0x3e8f58617928e588 */
+    5.17452463948269748331e-08,  /* 0x3e6bc7d000c38d48 */
+    9.38728274131605919153e-07,  /* 0x3eaf7f9d4e329998 */
+    2.73012191010840495544e-06,  /* 0x3ec6e6e464885269 */
+    3.29486051438996307950e-06,  /* 0x3ecba3a8b946c154 */
+    4.75803746362771416375e-06,  /* 0x3ed3f4e76110d5a4 */
+    3.33050940471947692369e-05,  /* 0x3f017622515a3e2b */
+    9.94707313972136215365e-06,  /* 0x3ee4dc4b528af3d0 */
+    6.51685096227860253398e-05,  /* 0x3f11156278615e10 */
+    1.18132406658066663359e-03,  /* 0x3f535ad50ed821f5 */
+    6.93090416366541877541e-04,  /* 0x3f46b61055f2935c */
+    1.45780415323416845386e-03,  /* 0x3f57e2794a601240 */
+    2.99862082708111758744e-02,  /* 0x3f9eb4b45f6aadd3 */
+    1.02539925859688602072e-02,  /* 0x3f85000b967b3698 */
+    1.26787669807076286421e-01,  /* 0x3fc03a940fadc092 */
+    6.86652631843830962843e-02,  /* 0x3fb1940bf3bf874c */
+    4.81593633223853068159e-01,  /* 0x3fded26e1a2a2110 */
+    1.70489514001513020602e+00,  /* 0x3ffb4740205796d6 */
+    1.12416073489841270572e+01,  /* 0x40267bb3f55cb85d */
+    7.06579578098005001152e+00,  /* 0x401c435ff81e18ac */
+    5.91244513000686140458e+01,  /* 0x404d8fee052bdea4 */
+    1.68921736147088438429e+02,  /* 0x40651d7edccde926 */
+    2.60692936262087528121e+02,  /* 0x40704b1644557e0e */
+    3.62419382134890611269e+02,  /* 0x4076a6b5ca0a9e1c */
+    4.07689930834187453002e+03,  /* 0x40afd9cc72249abe */
+    1.55377375868385224749e+04,  /* 0x40ce58de693edab5 */
+    2.53720210371943103382e+04,  /* 0x40d8c70158ac6364 */
+    4.78822310734952334315e+04,  /* 0x40e7614764f43e20 */
+    1.81871712615542812273e+05,  /* 0x4106337db36fc718 */
+    5.62892347580489004031e+05,  /* 0x41212d98b1f611e2 */
+    6.41374032312148716301e+05,  /* 0x412392bc108b37cc */
+    7.57809544070145115256e+06,  /* 0x415ce87bdc3473dc */
+    3.64177136406482197344e+06,  /* 0x414bc8d5ae99ad14 */
+    7.63580561355670914054e+06}; /* 0x415d20d76744835c */
+
+  unsigned long long ux, aux, xneg;
+  double y, z, z1, z2;
+  int m;
+
+  /* Special cases */
+
+  GET_BITS_DP64(x, ux);
+  aux = ux & ~SIGNBIT_DP64;
+  if (aux < 0x3e30000000000000) /* |x| small enough that cosh(x) = 1 */
+  {
+      if (aux == 0)
+        /* with no inexact */
+        return 1.0;
+      else
+        return val_with_flags(1.0, AMD_F_INEXACT);
+  }
+  else if (aux >= PINFBITPATT_DP64) /* |x| is NaN or Inf */
+    {
+      if (aux > PINFBITPATT_DP64) /* |x| is a NaN? */
+         return x + x;
+      else    /* x is infinity */
+         return infinity_with_flags(0);
+    }
+
+  xneg = (aux != ux);
+
+  y = x;
+  if (xneg) y = -x;
+
+  if (y >= max_cosh_arg)
+      {
+      /* Return +/-infinity with overflow flag */
+#ifdef WINDOWS
+         return handle_error("cosh", PINFBITPATT_DP64, _OVERFLOW,
+                              AMD_F_OVERFLOW, EDOM, x, 0.0F);
+#else
+      return retval_errno_erange(x);
+#endif
+
+
+      }
+  else if (y >= small_threshold)
+    {
+      /* In this range y is large enough so that
+         the negative exponential is negligible,
+         so cosh(y) is approximated by sign(x)*exp(y)/2. The
+         code below is an inlined version of that from
+         exp() with two changes (it operates on
+         y instead of x, and the division by 2 is
+         done by reducing m by 1). */
+
+      splitexp(y, 1.0, thirtytwo_by_log2, log2_by_32_lead,
+               log2_by_32_tail, &m, &z1, &z2);
+      m -= 1;
+
+      if (m >= EMIN_DP64 && m <= EMAX_DP64)
+        z = scaleDouble_1((z1+z2),m);
+      else
+        z = scaleDouble_2((z1+z2),m);
+    }
+  else
+    {
+      /* In this range we find the integer part y0 of y 
+         and the increment dy = y - y0. We then compute
+ 
+         z = sinh(y) = sinh(y0)cosh(dy) + cosh(y0)sinh(dy)
+         z = cosh(y) = cosh(y0)cosh(dy) + sinh(y0)sinh(dy)
+
+         where sinh(y0) and cosh(y0) are tabulated above. */
+
+      int ind;
+      double dy, dy2, sdy, cdy;
+
+      ind = (int)y;
+      dy = y - ind;
+
+      dy2 = dy*dy;
+      sdy = dy*dy2*(0.166666666666666667013899e0 +
+                    (0.833333333333329931873097e-2 +
+                     (0.198412698413242405162014e-3 +
+                      (0.275573191913636406057211e-5 +
+                       (0.250521176994133472333666e-7 +
+                        (0.160576793121939886190847e-9 +
+                         0.7746188980094184251527126e-12*dy2)*dy2)*dy2)*dy2)*dy2)*dy2);
+
+      cdy = dy2*(0.500000000000000005911074e0 +
+                 (0.416666666666660876512776e-1 +
+                  (0.138888888889814854814536e-2 +
+                   (0.248015872460622433115785e-4 +
+                    (0.275573350756016588011357e-6 +
+                     (0.208744349831471353536305e-8 +
+                      0.1163921388172173692062032e-10*dy2)*dy2)*dy2)*dy2)*dy2)*dy2);
+
+      /* At this point sinh(dy) is approximated by dy + sdy, and cosh(dy) is approximated by 1 + cdy.
+	 Shift some significant bits from dy to cdy. */
+      z = ((((((cosh_tail[ind]*cdy + sinh_tail[ind]*sdy) 
+	       + sinh_tail[ind]*dy) + cosh_tail[ind])  
+	     + cosh_lead[ind]*cdy) + sinh_lead[ind]*sdy) 
+	   + sinh_lead[ind]*dy) + cosh_lead[ind];
+    }
+
+  return z;
+}
+
+weak_alias (__cosh, cosh)
diff --git a/src/coshf.c b/src/coshf.c
new file mode 100644
index 0000000..ab2b68e
--- /dev/null
+++ b/src/coshf.c
@@ -0,0 +1,268 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#define USE_SPLITEXP
+#define USE_SCALEDOUBLE_1
+#define USE_SCALEDOUBLE_2
+#define USE_INFINITYF_WITH_FLAGS
+#define USE_VALF_WITH_FLAGS
+#include "../inc/libm_inlines_amd.h"
+#undef USE_SPLITEXP
+#undef USE_SCALEDOUBLE_1
+#undef USE_SCALEDOUBLE_2
+#undef USE_INFINITYF_WITH_FLAGS
+#undef USE_VALF_WITH_FLAGS
+
+#include "../inc/libm_errno_amd.h"
+
+#ifndef WINDOWS
+/* Deal with errno for out-of-range result */
+static inline float retval_errno_erange(float x)
+{
+  struct exception exc;
+  exc.arg1 = (double)x;
+  exc.arg2 = (double)x;
+  exc.type = OVERFLOW;
+  exc.name = (char *)"coshf";
+  if (_LIB_VERSION == _SVID_)
+    {
+        exc.retval = HUGE;
+    }
+  else
+    {
+        exc.retval = infinityf_with_flags(AMD_F_OVERFLOW);
+    }
+  if (_LIB_VERSION == _POSIX_)
+    __set_errno(ERANGE);
+  else if (!matherr(&exc))
+    __set_errno(ERANGE);
+  return exc.retval;
+}
+
+#endif
+float FN_PROTOTYPE(coshf)(float fx)
+{
+  /*
+    After dealing with special cases the computation is split into
+    regions as follows:
+
+    abs(x) >= max_cosh_arg:
+    cosh(x) = sign(x)*Inf
+
+    abs(x) >= small_threshold:
+    cosh(x) = sign(x)*exp(abs(x))/2 computed using the
+    splitexp and scaleDouble functions as for exp_amd().
+
+    abs(x) < small_threshold:
+    compute p = exp(y) - 1 and then z = 0.5*(p+(p/(p+1.0)))
+    cosh(x) is then sign(x)*z.                             */
+
+  static const double
+    /* The max argument of coshf, but stored as a double */
+    max_cosh_arg = 8.94159862922329438106e+01, /* 0x40565a9f84f82e63 */
+    thirtytwo_by_log2 = 4.61662413084468283841e+01, /* 0x40471547652b82fe */
+    log2_by_32_lead = 2.16608493356034159660e-02, /* 0x3f962e42fe000000 */
+    log2_by_32_tail = 5.68948749532545630390e-11, /* 0x3dcf473de6af278e */
+
+    small_threshold = 8*BASEDIGITS_DP64*0.30102999566398119521373889;
+//    small_threshold = 20.0;
+  /* (8*BASEDIGITS_DP64*log10of2) ' exp(-x) insignificant c.f. exp(x) */
+
+  /* Tabulated values of sinh(i) and cosh(i) for i = 0,...,36. */
+
+  static const double sinh_lead[   37] = {
+    0.00000000000000000000e+00,  /* 0x0000000000000000 */
+    1.17520119364380137839e+00,  /* 0x3ff2cd9fc44eb982 */
+    3.62686040784701857476e+00,  /* 0x400d03cf63b6e19f */
+    1.00178749274099008204e+01,  /* 0x40240926e70949ad */
+    2.72899171971277496596e+01,  /* 0x403b4a3803703630 */
+    7.42032105777887522891e+01,  /* 0x40528d0166f07374 */
+    2.01713157370279219549e+02,  /* 0x406936d22f67c805 */
+    5.48316123273246489589e+02,  /* 0x408122876ba380c9 */
+    1.49047882578955000099e+03,  /* 0x409749ea514eca65 */
+    4.05154190208278987484e+03,  /* 0x40afa7157430966f */
+    1.10132328747033916443e+04,  /* 0x40c5829dced69991 */
+    2.99370708492480553105e+04,  /* 0x40dd3c4488cb48d6 */
+    8.13773957064298447222e+04,  /* 0x40f3de1654d043f0 */
+    2.21206696003330085659e+05,  /* 0x410b00b5916a31a5 */
+    6.01302142081972560845e+05,  /* 0x412259ac48bef7e3 */
+    1.63450868623590236530e+06,  /* 0x4138f0ccafad27f6 */
+    4.44305526025387924165e+06,  /* 0x4150f2ebd0a7ffe3 */
+    1.20774763767876271158e+07,  /* 0x416709348c0ea4ed */
+    3.28299845686652474105e+07,  /* 0x417f4f22091940bb */
+    8.92411504815936237574e+07,  /* 0x419546d8f9ed26e1 */
+    2.42582597704895108938e+08,  /* 0x41aceb088b68e803 */
+    6.59407867241607308388e+08,  /* 0x41c3a6e1fd9eecfd */
+    1.79245642306579566002e+09,  /* 0x41dab5adb9c435ff */
+    4.87240172312445068359e+09,  /* 0x41f226af33b1fdc0 */
+    1.32445610649217357635e+10,  /* 0x4208ab7fb5475fb7 */
+    3.60024496686929321289e+10,  /* 0x4220c3d3920962c8 */
+    9.78648047144193725586e+10,  /* 0x4236c932696a6b5c */
+    2.66024120300899291992e+11,  /* 0x424ef822f7f6731c */
+    7.23128532145737548828e+11,  /* 0x42650bba3796379a */
+    1.96566714857202099609e+12,  /* 0x427c9aae4631c056 */
+    5.34323729076223046875e+12,  /* 0x429370470aec28ec */
+    1.45244248326237109375e+13,  /* 0x42aa6b765d8cdf6c */
+    3.94814800913403437500e+13,  /* 0x42c1f43fcc4b662c */
+    1.07321789892958031250e+14,  /* 0x42d866f34a725782 */
+    2.91730871263727437500e+14,  /* 0x42f0953e2f3a1ef7 */
+    7.93006726156715250000e+14,  /* 0x430689e221bc8d5a */
+    2.15561577355759750000e+15}; /* 0x431ea215a1d20d76 */
+
+  static const double cosh_lead[   37] = {
+    1.00000000000000000000e+00,  /* 0x3ff0000000000000 */
+    1.54308063481524371241e+00,  /* 0x3ff8b07551d9f550 */
+    3.76219569108363138810e+00,  /* 0x400e18fa0df2d9bc */
+    1.00676619957777653269e+01,  /* 0x402422a497d6185e */
+    2.73082328360164865444e+01,  /* 0x403b4ee858de3e80 */
+    7.42099485247878334349e+01,  /* 0x40528d6fcbeff3a9 */
+    2.01715636122455890700e+02,  /* 0x406936e67db9b919 */
+    5.48317035155212010977e+02,  /* 0x4081228949ba3a8b */
+    1.49047916125217807348e+03,  /* 0x409749eaa93f4e76 */
+    4.05154202549259389343e+03,  /* 0x40afa715845d8894 */
+    1.10132329201033226127e+04,  /* 0x40c5829dd053712d */
+    2.99370708659497577173e+04,  /* 0x40dd3c4489115627 */
+    8.13773957125740562333e+04,  /* 0x40f3de1654d6b543 */
+    2.21206696005590405548e+05,  /* 0x410b00b5916b6105 */
+    6.01302142082804115489e+05,  /* 0x412259ac48bf13ca */
+    1.63450868623620807193e+06,  /* 0x4138f0ccafad2d17 */
+    4.44305526025399193168e+06,  /* 0x4150f2ebd0a8005c */
+    1.20774763767876680940e+07,  /* 0x416709348c0ea503 */
+    3.28299845686652623117e+07,  /* 0x417f4f22091940bf */
+    8.92411504815936237574e+07,  /* 0x419546d8f9ed26e1 */
+    2.42582597704895138741e+08,  /* 0x41aceb088b68e804 */
+    6.59407867241607308388e+08,  /* 0x41c3a6e1fd9eecfd */
+    1.79245642306579566002e+09,  /* 0x41dab5adb9c435ff */
+    4.87240172312445068359e+09,  /* 0x41f226af33b1fdc0 */
+    1.32445610649217357635e+10,  /* 0x4208ab7fb5475fb7 */
+    3.60024496686929321289e+10,  /* 0x4220c3d3920962c8 */
+    9.78648047144193725586e+10,  /* 0x4236c932696a6b5c */
+    2.66024120300899291992e+11,  /* 0x424ef822f7f6731c */
+    7.23128532145737548828e+11,  /* 0x42650bba3796379a */
+    1.96566714857202099609e+12,  /* 0x427c9aae4631c056 */
+    5.34323729076223046875e+12,  /* 0x429370470aec28ec */
+    1.45244248326237109375e+13,  /* 0x42aa6b765d8cdf6c */
+    3.94814800913403437500e+13,  /* 0x42c1f43fcc4b662c */
+    1.07321789892958031250e+14,  /* 0x42d866f34a725782 */
+    2.91730871263727437500e+14,  /* 0x42f0953e2f3a1ef7 */
+    7.93006726156715250000e+14,  /* 0x430689e221bc8d5a */
+    2.15561577355759750000e+15}; /* 0x431ea215a1d20d76 */
+
+  unsigned long long ux, aux, xneg;
+  double x = fx, y, z, z1, z2;
+  int m;
+
+  /* Special cases */
+
+  GET_BITS_DP64(x, ux);
+  aux = ux & ~SIGNBIT_DP64;
+  if (aux < 0x3f10000000000000) /* |x| small enough that cosh(x) = 1 */
+    {
+      if (aux == 0) return (float)1.0; /* with no inexact */
+      if (LAMBDA_DP64 + x  > 1.0) return valf_with_flags((float)1.0, AMD_F_INEXACT); /* with inexact */
+    }
+  else if (aux >= PINFBITPATT_DP64) /* |x| is NaN or Inf */
+    {
+      if (aux > PINFBITPATT_DP64) /* |x| is a NaN? */
+         return fx + fx;
+      else    /* x is infinity */
+         return infinityf_with_flags(0);
+    }
+
+  xneg = (aux != ux);
+
+  y = x;
+  if (xneg) y = -x;
+
+  if (y >= max_cosh_arg)
+    {
+      /* Return infinity with overflow flag. */
+      /* This handles POSIX behaviour */
+      __set_errno(ERANGE);
+        z = infinityf_with_flags(AMD_F_OVERFLOW);
+    }
+  else if (y >= small_threshold)
+    {
+      /* In this range y is large enough so that
+         the negative exponential is negligible,
+         so cosh(y) is approximated by sign(x)*exp(y)/2. The
+         code below is an inlined version of that from
+         exp() with two changes (it operates on
+         y instead of x, and the division by 2 is
+         done by reducing m by 1). */
+
+      splitexp(y, 1.0, thirtytwo_by_log2, log2_by_32_lead,
+               log2_by_32_tail, &m, &z1, &z2);
+      m -= 1;
+
+      /* scaleDouble_1 is always safe because the argument x was
+         float, rather than double */
+
+      z = scaleDouble_1((z1+z2),m);
+    }
+  else
+    {
+      /* In this range we find the integer part y0 of y 
+         and the increment dy = y - y0. We then compute
+ 
+         z = sinh(y) = sinh(y0)cosh(dy) + cosh(y0)sinh(dy)
+         z = cosh(y) = cosh(y0)cosh(dy) + sinh(y0)sinh(dy)
+
+         where sinh(y0) and cosh(y0) are tabulated above. */
+
+      int ind;
+      double dy, dy2, sdy, cdy;
+
+      ind = (int)y;
+      dy = y - ind;
+
+      dy2 = dy*dy;
+
+      sdy = dy + dy*dy2*(0.166666666666666667013899e0 +
+			 (0.833333333333329931873097e-2 +
+			  (0.198412698413242405162014e-3 +
+			   (0.275573191913636406057211e-5 +
+			    (0.250521176994133472333666e-7 +
+			     (0.160576793121939886190847e-9 +
+			      0.7746188980094184251527126e-12*dy2)*dy2)*dy2)*dy2)*dy2)*dy2);
+
+      cdy = 1 + dy2*(0.500000000000000005911074e0 +
+		     (0.416666666666660876512776e-1 +
+		      (0.138888888889814854814536e-2 +
+		       (0.248015872460622433115785e-4 +
+			(0.275573350756016588011357e-6 +
+			 (0.208744349831471353536305e-8 +
+			  0.1163921388172173692062032e-10*dy2)*dy2)*dy2)*dy2)*dy2)*dy2);
+
+      z = cosh_lead[ind]*cdy + sinh_lead[ind]*sdy;
+    }
+
+//  if (xneg) z = - z;
+  return (float)z;
+}
+
+weak_alias (__coshf, coshf)
diff --git a/src/exp_special.c b/src/exp_special.c
new file mode 100644
index 0000000..ca32ec2
--- /dev/null
+++ b/src/exp_special.c
@@ -0,0 +1,110 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+#ifdef __x86_64__
+
+#include <emmintrin.h>
+#include <math.h>
+#include <errno.h>
+
+#include "../inc/libm_util_amd.h"
+#include "../inc/libm_special.h"
+
+// y = expf(x)
+// y = exp(x)
+
+// these codes and the ones in the related .S or .asm files have to match
+#define EXP_X_NAN       1
+#define EXP_Y_ZERO      2
+#define EXP_Y_INF       3
+
+float _expf_special(float x, float y, U32 code)
+{
+    switch(code)
+    {
+    case EXP_X_NAN:
+        {
+#ifdef WIN64
+            // y is assumed to be qnan, only check x for snan
+            unsigned int is_x_snan;
+            UT32 xm; xm.f32 = x;
+            is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+            __amd_handle_errorf(DOMAIN, EDOM, "expf", x, is_x_snan, 0.0f, 0, y, 0);
+#else
+            _mm_setcsr(_mm_getcsr() | MXCSR_ES_INVALID);
+#endif
+        }
+        break;
+
+    case EXP_Y_ZERO:
+        {
+            _mm_setcsr(_mm_getcsr() | (MXCSR_ES_INEXACT|MXCSR_ES_UNDERFLOW));
+            __amd_handle_errorf(UNDERFLOW, ERANGE, "expf", x, 0, 0.0f, 0, y, 0);
+        }
+        break;
+
+    case EXP_Y_INF:
+        {
+            _mm_setcsr(_mm_getcsr() | (MXCSR_ES_INEXACT|MXCSR_ES_OVERFLOW));
+            __amd_handle_errorf(OVERFLOW, ERANGE, "expf", x, 0, 0.0f, 0, y, 0);
+        }
+        break;
+    }
+
+
+    return y;
+}
+
+double _exp_special(double x, double y, U32 code)
+{
+    switch(code)
+    {
+    case EXP_X_NAN:
+        {
+#ifdef WIN64
+            __amd_handle_error(DOMAIN, EDOM, "exp", x, 0.0, y);
+#else
+            _mm_setcsr(_mm_getcsr() | MXCSR_ES_INVALID);
+#endif
+        }
+        break;
+
+    case EXP_Y_ZERO:
+        {
+            _mm_setcsr(_mm_getcsr() | (MXCSR_ES_INEXACT|MXCSR_ES_UNDERFLOW));
+            __amd_handle_error(UNDERFLOW, ERANGE, "exp", x, 0.0, y);
+        }
+        break;
+
+    case EXP_Y_INF:
+        {
+            _mm_setcsr(_mm_getcsr() | (MXCSR_ES_INEXACT|MXCSR_ES_OVERFLOW));
+            __amd_handle_error(OVERFLOW, ERANGE, "exp", x, 0.0, y);
+        }
+        break;
+    }
+
+
+    return y;
+}
+
+#endif /* __x86_64__ */
diff --git a/src/finite.c b/src/finite.c
new file mode 100644
index 0000000..7e7ca39
--- /dev/null
+++ b/src/finite.c
@@ -0,0 +1,60 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+/* Returns 0 if x is infinite or NaN, otherwise returns 1 */
+
+#ifdef WINDOWS
+int FN_PROTOTYPE(finite)(double x)
+#else
+int FN_PROTOTYPE(finite)(double x)
+#endif
+{
+
+#ifdef WINDOWS
+
+  unsigned long long ux;
+  GET_BITS_DP64(x, ux);
+  return (int)(((ux & ~SIGNBIT_DP64) - PINFBITPATT_DP64) >> 63);
+
+#else
+
+  /* This works on Hammer with gcc */
+  unsigned long ux =0x7ff0000000000000 ;
+  double temp;
+  PUT_BITS_DP64(ux, temp);
+
+ // double temp = 1.0e444; /* = infinity = 0x7ff0000000000000 */
+  volatile int retval;
+  retval = 0;
+  asm volatile ("andpd	%0, %1;" : : "x" (temp), "x" (x));
+  asm volatile ("comisd	%0, %1" : : "x" (temp), "x" (x));
+  asm volatile ("setnz	%0" : "=g" (retval));
+  return retval;
+
+#endif
+}
+
+weak_alias (__finite, finite)
diff --git a/src/finitef.c b/src/finitef.c
new file mode 100644
index 0000000..8c0613a
--- /dev/null
+++ b/src/finitef.c
@@ -0,0 +1,60 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+/* Returns 0 if x is infinite or NaN, otherwise returns 1 */
+
+#ifdef WINDOWS
+int FN_PROTOTYPE(finitef)(float x)
+#else
+int FN_PROTOTYPE(finitef)(float x)
+#endif
+{
+
+#ifdef WINDOWS
+
+  unsigned int ux;
+  GET_BITS_SP32(x, ux);
+  return (int)(((ux & ~SIGNBIT_SP32) - PINFBITPATT_SP32) >> 31);
+
+#else
+
+  /* This works on Hammer */
+  unsigned int ux=0x7f800000;
+  float temp;    
+  PUT_BITS_SP32(ux, temp);
+
+ /* float temp = 1.0e444; *//* = infinity = 0x7f800000 */
+  volatile int retval;
+  retval = 0;
+  asm volatile ("andps	%0, %1;" : : "x" (temp), "x" (x));
+  asm volatile ("comiss	%0, %1" : : "x" (temp), "x" (x));
+  asm volatile ("setnz	%0" : "=g" (retval));
+  return retval;
+
+#endif
+}
+
+weak_alias (__finitef, finitef)
diff --git a/src/floor.c b/src/floor.c
new file mode 100644
index 0000000..a1b99c5
--- /dev/null
+++ b/src/floor.c
@@ -0,0 +1,92 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#ifdef WINDOWS
+#include "../inc/libm_errno_amd.h"
+#define USE_HANDLE_ERROR
+#include "../inc/libm_inlines_amd.h"
+#undef USE_HANDLE_ERROR
+#endif
+
+#ifdef WINDOWS
+#pragma function(floor)
+#endif
+
+double FN_PROTOTYPE(floor)(double x)
+{
+  double r;
+  long long rexp, xneg;
+
+
+  unsigned long long ux, ax, ur, mask;
+
+  GET_BITS_DP64(x, ux);
+  ax = ux & (~SIGNBIT_DP64);
+  xneg = (ux != ax);
+
+  if (ax >= 0x4340000000000000)
+    {
+      /* abs(x) is either NaN, infinity, or >= 2^53 */
+      if (ax > 0x7ff0000000000000)
+        /* x is NaN */
+#ifdef WINDOWS
+        return handle_error("floor", ux|0x0008000000000000, _DOMAIN,
+                            0, EDOM, x, 0.0);
+#else
+        return x + x; /* Raise invalid if it is a signalling NaN */
+#endif
+      else
+        return x;
+    }
+  else if (ax < 0x3ff0000000000000) /* abs(x) < 1.0 */
+    {
+      if (ax == 0x0000000000000000)
+        /* x is +zero or -zero; return the same zero */
+        return x;
+      else if (xneg) /* x < 0.0 */
+        return -1.0;
+      else
+        return 0.0;
+    }
+  else
+    {
+      r = x;
+      rexp = ((ux & EXPBITS_DP64) >> EXPSHIFTBITS_DP64) - EXPBIAS_DP64;
+      /* Mask out the bits of r that we don't want */
+      mask = 1;
+      mask = (mask << (EXPSHIFTBITS_DP64 - rexp)) - 1;
+      ur = (ux & ~mask);
+      PUT_BITS_DP64(ur, r);
+      if (xneg && (ur != ux))
+        /* We threw some bits away and x was negative */
+        return r - 1.0;
+      else
+        return r;
+    }
+
+}
+
+weak_alias (__floor, floor)
diff --git a/src/floorf.c b/src/floorf.c
new file mode 100644
index 0000000..e0f855b
--- /dev/null
+++ b/src/floorf.c
@@ -0,0 +1,87 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#ifdef WINDOWS
+#include "../inc/libm_errno_amd.h"
+#define USE_HANDLE_ERRORF
+#include "../inc/libm_inlines_amd.h"
+#undef USE_HANDLE_ERRORF
+#endif
+
+#ifdef WINDOWS
+#pragma function(floorf)
+#endif
+
+float FN_PROTOTYPE(floorf)(float x)
+{
+  float r;
+  int rexp, xneg;
+  unsigned int ux, ax, ur, mask;
+
+  GET_BITS_SP32(x, ux);
+  ax = ux & (~SIGNBIT_SP32);
+  xneg = (ux != ax);
+
+  if (ax >= 0x4b800000)
+    {
+      /* abs(x) is either NaN, infinity, or >= 2^24 */
+      if (ax > 0x7f800000)
+        /* x is NaN */
+#ifdef WINDOWS
+        return handle_errorf("floorf", ux|0x00400000, _DOMAIN,
+                             0, EDOM, x, 0.0F);
+#else
+        return x + x; /* Raise invalid if it is a signalling NaN */
+#endif
+      else
+        return x;
+    }
+  else if (ax < 0x3f800000) /* abs(x) < 1.0 */
+    {
+      if (ax == 0x00000000)
+        /* x is +zero or -zero; return the same zero */
+        return x;
+      else if (xneg) /* x < 0.0 */
+        return -1.0F;
+      else
+        return 0.0F;
+    }
+  else
+    {
+      rexp = ((ux & EXPBITS_SP32) >> EXPSHIFTBITS_SP32) - EXPBIAS_SP32;
+      /* Mask out the bits of r that we don't want */
+      mask = (1 << (EXPSHIFTBITS_SP32 - rexp)) - 1;
+      ur = (ux & ~mask);
+      PUT_BITS_SP32(ur, r);
+      if (xneg && (ux != ur))
+        /* We threw some bits away and x was negative */
+        return r - 1.0F;
+      else
+        return r;
+    }
+}
+
+weak_alias (__floorf, floorf)
diff --git a/src/frexp.c b/src/frexp.c
new file mode 100644
index 0000000..0ae109c
--- /dev/null
+++ b/src/frexp.c
@@ -0,0 +1,54 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+
+double FN_PROTOTYPE(frexp)(double value, int *exp)
+{
+    UT64 val;
+    unsigned int sign;
+    int exponent;
+    val.f64 = value;
+    sign = val.u32[1] & SIGNBIT_SP32;
+    val.u32[1] = val.u32[1] & ~SIGNBIT_SP32; /* remove the sign bit */
+    *exp = 0;
+    if((val.f64 == 0.0) || ((val.u32[1] & 0x7ff00000)== 0x7ff00000)) 
+        return value; /* value= +-0 or value= nan or value = +-inf return value */
+
+    exponent = val.u32[1] >> 20; /* get the exponent */
+
+    if(exponent == 0)/*x is denormal*/
+    {
+		val.f64 = val.f64 * VAL_2PMULTIPLIER_DP;/*multiply by 2^53 to bring it to the normal range*/
+        exponent = val.u32[1] >> 20; /* get the exponent */
+		exponent = exponent - MULTIPLIER_DP;
+    }
+
+	exponent -= 1022; /* remove bias(1023)-1 */
+    *exp = exponent; /* set the integral power of two */
+    val.u32[1] = sign | 0x3fe00000 | (val.u32[1] & 0x000fffff);/* make the fractional part(divide by 2) */                                              
+    return val.f64;
+}
+
diff --git a/src/frexpf.c b/src/frexpf.c
new file mode 100644
index 0000000..e2b4ece
--- /dev/null
+++ b/src/frexpf.c
@@ -0,0 +1,55 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+
+
+float FN_PROTOTYPE(frexpf)(float value, int *exp)
+{
+    UT32 val;
+    unsigned int sign;
+    int exponent;
+    val.f32 = value;
+    sign = val.u32 & SIGNBIT_SP32;
+    val.u32 = val.u32 & ~SIGNBIT_SP32; /* remove the sign bit */
+    *exp = 0;
+    if((val.f32 == 0.0) || ((val.u32 & 0x7f800000)== 0x7f800000)) 
+        return value; /* value= +-0 or value= nan or value = +-inf return value */
+
+    exponent = val.u32 >> 23; /* get the exponent */
+
+	if(exponent == 0)/*x is denormal*/
+	{
+		val.f32 = val.f32 * VAL_2PMULTIPLIER_SP;/*multiply by 2^24 to bring it to the normal range*/
+		exponent = (val.u32 >> 23); /* get the exponent */
+		exponent = exponent - MULTIPLIER_SP;
+	}
+
+    exponent -= 126; /* remove bias(127)-1 */
+    *exp = exponent; /* set the integral power of two */
+    val.u32 = sign | 0x3f000000 | (val.u32 & 0x007fffff);/* make the fractional part(divide by 2) */                                              
+    return val.f32;
+}
+
diff --git a/src/gas/cbrt.S b/src/gas/cbrt.S
new file mode 100644
index 0000000..b733a1a
--- /dev/null
+++ b/src/gas/cbrt.S
@@ -0,0 +1,1575 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+# cbrt.S
+#
+# An implementation of the cbrt libm function.
+#
+# Prototype:
+#
+#     double cbrt(double x);
+#
+
+#
+#   Algorithm:
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(cbrt)
+#define fname_special _cbrt_special
+
+
+# local variable storage offsets
+
+.equ   store_input, -0x10 
+.equ   stack_size, 0x20 
+
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 32
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+    xor   %rdx,%rdx
+    #for the time being the stack pointer is not changed at all 
+    #Assuming that this is a leaf procedure we can avoid the decrementing and incrementing
+    #of the stack pointer. This will save some assembly operations and give us good performance
+    #results. If there is a procedure call then we need to look at the changes in the stack pointer. 
+    #sub   $stack_size, %rsp
+    movd  %xmm0,%rax
+    movsd %xmm0,%xmm6
+    mov   .L__exp_mask_64(%rip),%r10
+    mov   .L__mantissa_mask_64(%rip),%r11
+    mov   %rax,%r9
+    and   %r10,%rax # rax = stores the exponent
+    and   %r11,%r9 # r9 = stores the mantissa
+    shr   $52,%rax
+    cmp   $0X7FF,%rax
+    jz    .L__cbrt_is_Nan_Infinite
+    cmp   $0X0,%rax
+    jz    .L__cbrt_is_denormal
+    
+.align 32
+.L__cbrt_is_normal:   
+    mov   $3,%rcx   # cx is set to 3 to perform division and get the scale and remainder
+    pand  .L__sign_bit_64(%rip),%xmm6  # xmm6 contains the sign
+    sub   $0x3FF,%ax
+    #we don't need the compare as sub instruction will raise the flags. But there was no performance improvement
+    cmp   $0,%ax 
+    jge   .L__donot_change_dx
+    not   %dx
+.L__donot_change_dx:
+    idiv  %cx #Accumulator is divided by bl=3
+              #ax contains the quotient
+              #dx contains the remainder
+    mov   %dx,%cx
+    add   $0x3FF,%ax
+    shl   $52,%rax
+    add   $2,%cx
+    shl   $1,%cx
+                 #ax = Contains the quotient, Scale factor
+    mov   %rax,store_input(%rsp)
+    movsd store_input(%rsp),%xmm7 #xmm7 is the scaling factor = mf
+    #xmm0 is the modified input value from the denaormal cases 
+    pand  .L__mantissa_mask_64(%rip),%xmm0
+    por   .L__zero_point_five(%rip),%xmm0 #xmm0 = Y
+    mov   %r9,%r10
+    shr   $43,%r10 
+    shr   $44,%r9 
+    and   $0x01,%r10
+    or    $0x0100,%r9
+    add   %r9,%r10 #r10 =  index_u64
+    cvtsi2sd %r10,%xmm4 #xmm4 = index_f64
+    sub $256,%r10
+    lea .L__INV_TAB_256(%rip),%rax
+    mulsd .L__one_by_512(%rip), %xmm4  #xmm4 = F
+    subsd %xmm4,%xmm0 # xmm0 = f
+    movsd (%rax,%r10,8),%xmm4 
+    mulsd %xmm4,%xmm0  # xmm0 = r 
+   
+    #Now perform polynomial computation
+    
+    # movddup %xmm0,%xmm0 # xmm0 = r  ,r
+    shufpd  $0,%xmm0,%xmm0 # replacing movddup
+
+    mulsd   %xmm0,%xmm0 # xmm0 = r  ,r^2
+
+    movapd   %xmm0,%xmm4 # xmm4 = r  ,r^2
+    movapd   %xmm0,%xmm3 # xmm3 = r  ,r^2
+    mulpd   %xmm0,%xmm0 # xmm0 = r^2,r^4   #########
+    mulpd   %xmm0,%xmm3 # xmm3 = r^3,r^6   #########
+    movapd  %xmm3,%xmm2
+    mulpd   .L__coefficients_3_6(%rip),%xmm2 # xmm2 = [coeff3 * r^3, coeff6 * r^6]
+    mulpd   %xmm0,%xmm3 # xmm3 = r^5,r^10 We don't need r^10
+    unpckhpd %xmm3,%xmm4 #xmm4 = r^5,r
+    mulpd   .L__coefficients_2_4(%rip),%xmm0 # xmm0 = [coeff2 * r^2, coeff4 * r^4]
+    mulpd   .L__coefficients_5_1(%rip),%xmm4 # xmm4 = [coeff5 * r^5, coeff1 * r  ]
+    movapd %xmm4,%xmm3
+    unpckhpd %xmm3,%xmm3          #xmm3 = [~Don't Care ,coeff5 * r^5]
+    addsd %xmm3,%xmm2 # xmm2 = [coeff3 * r^3, coeff5 * r^5 + coeff6 * r^6]
+    addpd %xmm2,%xmm0 # xmm0 = [coeff2 * r^2 + coeff3 * r^3,coeff4 * r^4 + coeff5 * r^5 + coeff6 * r^6]  
+    movapd %xmm0,%xmm2 
+    unpckhpd %xmm2,%xmm2          #xmm3 = [~Don't Care ,coeff2 * r^2 + coeff3 * r^3]
+    addsd  %xmm2,%xmm0 # xmm0 = [~Don't Care, coeff2 * r^2 + coeff3 * r^3 + coeff4 * r^4 + coeff5 * r^5 + coeff6 * r^6]
+    addsd  %xmm4,%xmm0 # xmm0 = [~Don't Care, coeff1 * r   + coeff2 * r^2 + coeff3 * r^3 + coeff4 * r^4 + coeff5 * r^5 + coeff6 * r^6]
+    
+    # movddup %xmm0,%xmm0
+    shufpd  $0,%xmm0,%xmm0 # replacing movddup
+
+    
+    #Polynomial computation completes here
+    #Now compute the following
+    #switch(rem)
+    #{
+    #    case -2:    cbrtRem_h.u64 = 0x3fe428a2f0000000; cbrtRem_t.u64 = 0x3e531ae515c447bb; break;
+    #    case -1:    cbrtRem_h.u64 = 0x3fe965fea0000000; cbrtRem_t.u64 = 0x3e44f5b8f20ac166; break;
+    #    case 0:     cbrtRem_h.u64 = 0x3ff0000000000000; cbrtRem_t.u64 = 0x0000000000000000; break;
+    #    case 1:     cbrtRem_h.u64 = 0x3ff428a2f0000000; cbrtRem_t.u64 = 0x3e631ae515c447bb; break;
+    #    case 2:     cbrtRem_h.u64 = 0x3ff965fea0000000; cbrtRem_t.u64 = 0x3e54f5b8f20ac166; break;
+    #    default:    break;
+    #}
+    #cbrtF_h.u64 = CBRT_F_H[index_u64-256];
+    #cbrtF_t.u64 = CBRT_F_T[index_u64-256];
+    #
+    #bH = (cbrtF_h.f64 * cbrtRem_h.f64);
+    #bT = ((((cbrtF_t.f64 * cbrtRem_t.f64)) + (cbrtF_t.f64 * cbrtRem_h.f64)) + (cbrtRem_t.f64 * cbrtF_h.f64));
+    lea .L__cuberoot_remainder_h_l(%rip),%r8  # load both head and tail of the remainders cuberoot at once
+    movapd (%r8,%rcx,8),%xmm1 # xmm1 = [cbrtRem_h.f64,cbrtRem_t.f64]
+    shl $1,%r10
+    lea .L__CBRT_F_H_L_256(%rip),%rax
+    movapd (%rax,%r10,8),%xmm2 # xmm2 = [cbrtF_h.f64,cbrtF_t.f64]
+    movapd %xmm2,%xmm3     
+    psrldq $8,%xmm3           # xmm3 = [~Dont Care,cbrtF_h.f64]
+    unpcklpd %xmm2,%xmm3      # xmm3 = [cbrtF_t.f64,cbrtF_h.f64]
+
+    mulpd  %xmm1,%xmm2        # xmm2 = [(cbrtF_h.f64*cbrtRem_h.f64),(cbrtRem_t.f64*cbrtF_t.f64)]
+    mulpd  %xmm1,%xmm3        # xmm3 = [(cbrtRem_h.f64*cbrtF_t.f64),(cbrtRem_t.f64*cbrtF_h.f64)]
+    movapd %xmm3,%xmm4        
+    unpckhpd %xmm4,%xmm4      # xmm4 = [(cbrtRem_h.f64*cbrtF_t.f64),(cbrtRem_h.f64*cbrtF_t.f64)]
+    addsd    %xmm4,%xmm3      # xmm3 = [~Dont Care, ((cbrtRem_h.f64*cbrtF_t.f64) + (cbrtRem_t.f64*cbrtF_h.f64))]
+    addsd    %xmm3,%xmm2      # xmm2 = [(cbrtF_h.f64*cbrtRem_h.f64),(((cbrtRem_t.f64*cbrtF_t.f64)+(cbrtRem_h.f64*cbrtF_t.f64) + (cbrtRem_t.f64*cbrtF_h.f64))]
+                              # xmm2 = [bH,bT]
+    # Now calculate
+    #ans.f64 = (((((z * bT)) + (bT)) + (z * bH)) + (bH));
+    #ans.f64 = ans.f64 * mf;
+    #ans.u64 = ans.u64 | sign.u64;
+
+    movapd   %xmm2,%xmm3
+    unpckhpd %xmm3,%xmm3      # xmm3 = [Dont Care,bH]
+                              # also xmm0 = [z,z] = the polynomial which was computed earlier
+    mulpd    %xmm2,%xmm0      # xmm0 = [(bH*z),(bT*z)]
+    movapd   %xmm0,%xmm4      
+    unpckhpd %xmm4,%xmm4      # xmm4 = [(bH*z),(bH*z)]
+    addsd    %xmm2,%xmm0      # xmm0 = [~DontCare, ((bT*z) + bT)]
+    unpckhpd %xmm2,%xmm2      # xmm2 = [(bH),(bH)]
+    addsd    %xmm4,%xmm0      # xmm0 = [~DontCare, (((bT*z) + bT) + ( z*bH))]
+    addsd    %xmm2,%xmm0      # xmm0 = [~DontCare, ((((bT*z) + bT) + (z*bH)) + bH)] = [~Dont Care,ans.f64]
+    mulsd    %xmm7,%xmm0      # xmm0 = ans.f64 * mf; mf is the scaling factor
+    por      %xmm6,%xmm0      # restore the sign
+    #add   $stack_size, %rsp
+    ret
+    
+         
+.align 32
+.L__cbrt_is_denormal:
+    movsd  .L__one_mask_64(%rip),%xmm4
+    cmp    $0,%r9
+    jz     .L__cbrt_is_zero
+    pand  .L__sign_mask_64(%rip),%xmm0   
+    por    %xmm4,%xmm0
+    subsd  %xmm4,%xmm0
+    movd   %xmm0,%rax
+    mov    %rax,%r9
+    and    %r10,%rax # rax = stores the exponent
+    and    %r11,%r9 # r9 = stores the mantissa
+    shr    $52,%rax
+    sub    $1022,%rax
+    jmp    .L__cbrt_is_normal
+
+.align 32
+.L__cbrt_is_zero:
+    ret
+.align 32
+.L__cbrt_is_Nan_Infinite:
+    cmp $0,%r9
+    jz .L__cbrt_is_Infinite
+    mulsd %xmm0,%xmm0 #this multiplication will raise an invalid exception
+    por  .L__qnan_mask_64(%rip),%xmm0
+.L__cbrt_is_Infinite: 
+    #add   $stack_size, %rsp
+    ret
+
+.align 32 
+.L__mantissa_mask_64:      .quad 0x000FFFFFFFFFFFFF
+                           .quad 0          #this zero is necessary
+.L__qnan_mask_64:          .quad 0x0008000000000000
+.L__exp_mask_64:           .quad 0x7FF0000000000000
+                           .quad 0
+.L__zero:                  .quad 0x0000000000000000
+                           .quad 0
+.align 32                           
+.L__zero_point_five:       .quad 0x3FE0000000000000
+                           .quad 0
+.align 16
+.L__sign_mask_64:          .quad 0x7FFFFFFFFFFFFFFF 
+                           .quad 0
+.L__sign_bit_64:           .quad 0x8000000000000000 
+                           .quad 0
+.L__one_mask_64:           .quad 0x3FF0000000000000 
+                           .quad 0
+.L__one_by_512:            .quad 0x3f60000000000000
+                           .quad 0
+
+
+.align 16
+.L__denormal_factor:       .quad 0x3F7428A2F98D728B 
+                           .quad 0
+# The coeeficients are arranged in a specific order to aid parrallel multiplication
+# The numbers corresponding to each coeff corresponds to the rth order to which it is to 
+# be multiplied 
+.L__coefficients:           
+.align 32 
+.L__coefficients_5_1:       .quad 0x3fd5555555555555 # 1
+                            .quad 0x3f9ee7113506ac13 # 5
+.L__coefficients_2_4:       .quad 0xbfa511e8d2b3183b # 4
+                            .quad 0xbfbc71c71c71c71c # 2
+.L__coefficients_3_6:       .quad 0xbf98090d6221a247 # 6
+                            .quad 0x3faf9add3c0ca458 # 3
+                            .quad 0x3f93750ad588f114 # 7
+
+
+
+.align 32
+.L__cuberoot_remainder_h_l: 
+                            .quad 0x3e531ae515c447bb  # cbrt(2^-2) Low
+                            .quad 0x3FE428A2F0000000  # cbrt(2^-2) High
+                            .quad 0x3e44f5b8f20ac166  # cbrt(2^-1) Low
+                            .quad 0x3FE965FEA0000000  # cbrt(2^-1) High
+                            .quad 0x0000000000000000  # cbrt(2^0) Low
+                            .quad 0x3FF0000000000000  # cbrt(2^0) High
+                            .quad 0x3e631ae515c447bb  # cbrt(2^1) Low
+                            .quad 0x3FF428A2F0000000  # cbrt(2^1) High
+                            .quad 0x3e54f5b8f20ac166  # cbrt(2^2) Low
+                            .quad 0x3FF965FEA0000000  # cbrt(2^2) High
+
+
+
+#interleaved high and low values
+.align 32
+.L__CBRT_F_H_L_256:
+	.quad 0x0000000000000000							
+    .quad 0x3ff0000000000000
+	.quad 0x3e6e6a24c81e4294							
+    .quad 0x3ff0055380000000
+	.quad 0x3e58548511e3a785							
+    .quad 0x3ff00aa390000000
+	.quad 0x3e64eb9336ec07f6							
+    .quad 0x3ff00ff010000000
+	.quad 0x3e40ea64b8b750e1							
+    .quad 0x3ff0153920000000
+	.quad 0x3e461637cff8a53c							
+    .quad 0x3ff01a7eb0000000
+	.quad 0x3e40733bf7bd1943
+    .quad 0x3ff01fc0d0000000
+	.quad 0x3e5666911345cced
+    .quad 0x3ff024ff80000000
+	.quad 0x3e477b7a3f592f14							
+    .quad 0x3ff02a3ad0000000
+	.quad 0x3e6f18d3dd1a5402							
+    .quad 0x3ff02f72b0000000
+	.quad 0x3e2be2f5a58ee9a4							
+    .quad 0x3ff034a750000000
+	.quad 0x3e68901f8f085fa7							
+    .quad 0x3ff039d880000000
+	.quad 0x3e5c68b8cd5b5d69							
+    .quad 0x3ff03f0670000000
+	.quad 0x3e5a6b0e8624be42							
+    .quad 0x3ff0443110000000
+	.quad 0x3dbc4b22b06f68e7							
+    .quad 0x3ff0495870000000
+	.quad 0x3e60f3f0afcabe9b							
+    .quad 0x3ff04e7c80000000
+	.quad 0x3e548495bca4e1b7							
+    .quad 0x3ff0539d60000000
+	.quad 0x3e66107f1abdfdc3							
+    .quad 0x3ff058bb00000000
+	.quad 0x3e6e67261878288a							
+    .quad 0x3ff05dd570000000
+	.quad 0x3e5a6bc155286f1e							
+    .quad 0x3ff062ecc0000000
+	.quad 0x3e58a759c64a85f2							
+    .quad 0x3ff06800e0000000
+	.quad 0x3e45fce70a4a8d09							
+    .quad 0x3ff06d11e0000000
+	.quad 0x3e32f9cbf373fe1d							
+    .quad 0x3ff0721fc0000000
+	.quad 0x3e590564ce4ac359							
+    .quad 0x3ff0772a80000000
+	.quad 0x3e5ac29ce761b02f							
+    .quad 0x3ff07c3230000000
+	.quad 0x3e5cb752f497381c							
+    .quad 0x3ff08136d0000000
+	.quad 0x3e68bb9e1cfb35e0							
+    .quad 0x3ff0863860000000
+	.quad 0x3e65b4917099de90							
+    .quad 0x3ff08b36f0000000
+	.quad 0x3e5cc77ac9c65ef2							
+    .quad 0x3ff0903280000000
+	.quad 0x3e57a0f3e7be3dba							
+    .quad 0x3ff0952b10000000
+	.quad 0x3e66ec851ee0c16f							
+    .quad 0x3ff09a20a0000000
+	.quad 0x3e689449bf2946da							
+    .quad 0x3ff09f1340000000
+	.quad 0x3e698f25301ba223							
+    .quad 0x3ff0a402f0000000
+	.quad 0x3e347d5ec651f549							
+    .quad 0x3ff0a8efc0000000
+	.quad 0x3e6c33ec9a86007a							
+    .quad 0x3ff0add990000000
+	.quad 0x3e5e0b6653e92649							
+    .quad 0x3ff0b2c090000000
+	.quad 0x3e3bd64ac09d755f							
+    .quad 0x3ff0b7a4b0000000
+	.quad 0x3e2f537506f78167							
+    .quad 0x3ff0bc85f0000000
+	.quad 0x3e62c382d1b3735e							
+    .quad 0x3ff0c16450000000
+	.quad 0x3e6e20ed659f99e1							
+    .quad 0x3ff0c63fe0000000
+	.quad 0x3e586b633a9c182a							
+    .quad 0x3ff0cb18b0000000
+	.quad 0x3e445cfd5a65e777							
+    .quad 0x3ff0cfeeb0000000
+	.quad 0x3e60c8770f58bca4							
+    .quad 0x3ff0d4c1e0000000
+	.quad 0x3e6739e44b0933c5							
+    .quad 0x3ff0d99250000000
+	.quad 0x3e027dc3d9ce7bd8							
+    .quad 0x3ff0de6010000000
+	.quad 0x3e63c53c7c5a7b64							
+    .quad 0x3ff0e32b00000000
+	.quad 0x3e69669683830cec							
+    .quad 0x3ff0e7f340000000
+	.quad 0x3e68d772c39bdcc4							
+    .quad 0x3ff0ecb8d0000000
+	.quad 0x3e69b0008bcf6d7b							
+    .quad 0x3ff0f17bb0000000
+	.quad 0x3e3bbb305825ce4f							
+    .quad 0x3ff0f63bf0000000
+	.quad 0x3e6da3f4af13a406							
+    .quad 0x3ff0faf970000000
+	.quad 0x3e5f36b96f74ce86							
+    .quad 0x3ff0ffb460000000
+	.quad 0x3e165c002303f790							
+    .quad 0x3ff1046cb0000000
+	.quad 0x3e682f84095ba7d5							
+    .quad 0x3ff1092250000000
+	.quad 0x3e6d46433541b2c6							
+    .quad 0x3ff10dd560000000
+	.quad 0x3e671c3d56e93a89							
+    .quad 0x3ff11285e0000000
+	.quad 0x3e598dcef4e40012							
+    .quad 0x3ff11733d0000000
+	.quad 0x3e4530ebef17fe03							
+    .quad 0x3ff11bdf30000000
+	.quad 0x3e4e8b8fa3715066							
+    .quad 0x3ff1208800000000
+	.quad 0x3e6ab26eb3b211dc							
+    .quad 0x3ff1252e40000000
+	.quad 0x3e454dd4dc906307							
+    .quad 0x3ff129d210000000
+	.quad 0x3e5c9f962387984e							
+    .quad 0x3ff12e7350000000
+	.quad 0x3e6c62a959afec09							
+    .quad 0x3ff1331210000000
+	.quad 0x3e6638d9ac6a866a
+    .quad 0x3ff137ae60000000
+	.quad 0x3e338704eca8a22d							
+    .quad 0x3ff13c4840000000
+	.quad 0x3e4e6c9e1db14f8f							
+    .quad 0x3ff140dfa0000000
+	.quad 0x3e58744b7f9c9eaa							
+    .quad 0x3ff1457490000000
+	.quad 0x3e66c2893486373b							
+    .quad 0x3ff14a0710000000
+	.quad 0x3e5b36bce31699b7							
+    .quad 0x3ff14e9730000000
+	.quad 0x3e671e3813d200c7							
+    .quad 0x3ff15324e0000000
+	.quad 0x3e699755ab40aa88							
+    .quad 0x3ff157b030000000
+	.quad 0x3e6b45ca0e4bcfc0							
+    .quad 0x3ff15c3920000000
+	.quad 0x3e32dd090d869c5d							
+    .quad 0x3ff160bfc0000000
+	.quad 0x3e64fe0516b917da
+    .quad 0x3ff16543f0000000
+	.quad 0x3e694563226317a2							
+    .quad 0x3ff169c5d0000000
+	.quad 0x3e653d8fafc2c851							
+    .quad 0x3ff16e4560000000
+	.quad 0x3e5dcbd41fbd41a3							
+    .quad 0x3ff172c2a0000000
+	.quad 0x3e5862ff5285f59c							
+    .quad 0x3ff1773d90000000
+	.quad 0x3e63072ea97a1e1c							
+    .quad 0x3ff17bb630000000
+	.quad 0x3e52839075184805							
+    .quad 0x3ff1802c90000000
+	.quad 0x3e64b0323e9eff42							
+    .quad 0x3ff184a0a0000000
+	.quad 0x3e6b158893c45484							
+    .quad 0x3ff1891270000000
+	.quad 0x3e3149ef0fc35826							
+    .quad 0x3ff18d8210000000
+	.quad 0x3e5f2e77ea96acaa							
+    .quad 0x3ff191ef60000000
+	.quad 0x3e5200074c471a95							
+    .quad 0x3ff1965a80000000
+	.quad 0x3e63f8cc517f6f04							
+    .quad 0x3ff19ac360000000
+	.quad 0x3e660ba2e311bb55							
+    .quad 0x3ff19f2a10000000
+	.quad 0x3e64b788730bbec3							
+    .quad 0x3ff1a38e90000000
+	.quad 0x3e657090795ee20c							
+    .quad 0x3ff1a7f0e0000000
+	.quad 0x3e6d9ffe983670b1							
+    .quad 0x3ff1ac5100000000
+	.quad 0x3e62a463ff61bfda							
+    .quad 0x3ff1b0af00000000
+	.quad 0x3e69d1bc6a5e65cf							
+    .quad 0x3ff1b50ad0000000
+	.quad 0x3e68718abaa9e922							
+    .quad 0x3ff1b96480000000
+	.quad 0x3e63c2f52ffa342e							
+    .quad 0x3ff1bdbc10000000
+	.quad 0x3e60fae13ff42c80							
+    .quad 0x3ff1c21180000000
+	.quad 0x3e65440f0ef00d57							
+    .quad 0x3ff1c664d0000000
+	.quad 0x3e46fcd22d4e3c1e							
+    .quad 0x3ff1cab610000000
+	.quad 0x3e4e0c60b409e863							
+    .quad 0x3ff1cf0530000000
+	.quad 0x3e6f9cab5a5f0333							
+    .quad 0x3ff1d35230000000
+	.quad 0x3e630f24744c333d							
+    .quad 0x3ff1d79d30000000
+	.quad 0x3e4b50622a76b2fe							
+    .quad 0x3ff1dbe620000000
+	.quad 0x3e6fdb94ba595375							
+    .quad 0x3ff1e02cf0000000
+	.quad 0x3e3861b9b945a171							
+    .quad 0x3ff1e471d0000000
+	.quad 0x3e654348015188c4							
+    .quad 0x3ff1e8b490000000
+	.quad 0x3e6b54d149865523							
+    .quad 0x3ff1ecf550000000
+	.quad 0x3e6a0bb783d9de33							
+    .quad 0x3ff1f13410000000
+	.quad 0x3e6629d12b1a2157							
+    .quad 0x3ff1f570d0000000
+	.quad 0x3e6467fe35d179df							
+    .quad 0x3ff1f9ab90000000
+	.quad 0x3e69763f3e26c8f7							
+    .quad 0x3ff1fde450000000
+	.quad 0x3e53f798bb9f7679							
+    .quad 0x3ff2021b20000000
+	.quad 0x3e552e577e855898							
+    .quad 0x3ff2064ff0000000
+	.quad 0x3e6fde47e5502c3a							
+    .quad 0x3ff20a82c0000000
+	.quad 0x3e5cbd0b548d96a0							
+    .quad 0x3ff20eb3b0000000
+	.quad 0x3e6a9cd9f7be8de8							
+    .quad 0x3ff212e2a0000000
+	.quad 0x3e522bbe704886de							
+    .quad 0x3ff2170fb0000000
+	.quad 0x3e6e3dea8317f020							
+    .quad 0x3ff21b3ac0000000
+	.quad 0x3e6e812085ac8855							
+    .quad 0x3ff21f63f0000000
+	.quad 0x3e5c87144f24cb07							
+    .quad 0x3ff2238b40000000
+	.quad 0x3e61e128ee311fa2							
+    .quad 0x3ff227b0a0000000
+	.quad 0x3e5b5c163d61a2d3							
+    .quad 0x3ff22bd420000000
+	.quad 0x3e47d97e7fb90633							
+    .quad 0x3ff22ff5c0000000
+	.quad 0x3e6efe899d50f6a7							
+    .quad 0x3ff2341570000000
+	.quad 0x3e6d0333eb75de5a							
+    .quad 0x3ff2383350000000
+	.quad 0x3e40e590be73a573							
+    .quad 0x3ff23c4f60000000
+	.quad 0x3e68ce8dcac3cdd2							
+    .quad 0x3ff2406980000000
+	.quad 0x3e6ee8a48954064b							
+    .quad 0x3ff24481d0000000
+	.quad 0x3e6aa62f18461e09							
+    .quad 0x3ff2489850000000
+	.quad 0x3e601e5940986a15							
+    .quad 0x3ff24cad00000000
+	.quad 0x3e3b082f4f9b8d4c							
+    .quad 0x3ff250bfe0000000
+	.quad 0x3e6876e0e5527f5a							
+    .quad 0x3ff254d0e0000000
+	.quad 0x3e63617080831e6b							
+    .quad 0x3ff258e020000000
+	.quad 0x3e681b26e34aa4a2							
+    .quad 0x3ff25ced90000000
+	.quad 0x3e552ee66dfab0c1							
+    .quad 0x3ff260f940000000
+	.quad 0x3e5d85a5329e8819							
+    .quad 0x3ff2650320000000
+	.quad 0x3e5105c1b646b5d1							
+    .quad 0x3ff2690b40000000
+	.quad 0x3e6bb6690c1a379c							
+    .quad 0x3ff26d1190000000
+	.quad 0x3e586aeba73ce3a9							
+    .quad 0x3ff2711630000000
+	.quad 0x3e6dd16198294dd4							
+    .quad 0x3ff2751900000000
+	.quad 0x3e6454e675775e83							
+    .quad 0x3ff2791a20000000
+	.quad 0x3e63842e026197ea							
+    .quad 0x3ff27d1980000000
+	.quad 0x3e6f1ce0e70c44d2							
+    .quad 0x3ff2811720000000
+	.quad 0x3e6ad636441a5627							
+    .quad 0x3ff2851310000000
+	.quad 0x3e54c205d7212abb							
+    .quad 0x3ff2890d50000000
+	.quad 0x3e6167c86c116419							
+    .quad 0x3ff28d05d0000000
+	.quad 0x3e638ec3ef16e294							
+    .quad 0x3ff290fca0000000
+	.quad 0x3e6473fceace9321							
+    .quad 0x3ff294f1c0000000
+	.quad 0x3e67af53a836dba7							
+    .quad 0x3ff298e530000000
+	.quad 0x3e1a51f3c383b652							
+    .quad 0x3ff29cd700000000
+	.quad 0x3e63696da190822d							
+    .quad 0x3ff2a0c710000000
+	.quad 0x3e62f9adec77074b							
+    .quad 0x3ff2a4b580000000
+	.quad 0x3e38190fd5bee55f							
+    .quad 0x3ff2a8a250000000
+	.quad 0x3e4bfee8fac68e55							
+    .quad 0x3ff2ac8d70000000
+	.quad 0x3e331c9d6bc5f68a							
+    .quad 0x3ff2b076f0000000
+	.quad 0x3e689d0523737edf							
+    .quad 0x3ff2b45ec0000000
+	.quad 0x3e5a295943bf47bb							
+    .quad 0x3ff2b84500000000
+	.quad 0x3e396be32e5b3207							
+    .quad 0x3ff2bc29a0000000
+	.quad 0x3e6e44c7d909fa0e							
+    .quad 0x3ff2c00c90000000
+	.quad 0x3e2b2505da94d9ea							
+    .quad 0x3ff2c3ee00000000
+	.quad 0x3e60c851f46c9c98							
+    .quad 0x3ff2c7cdc0000000
+	.quad 0x3e5da71f7d9aa3b7							
+    .quad 0x3ff2cbabf0000000
+	.quad 0x3e6f1b605d019ef1							
+    .quad 0x3ff2cf8880000000
+	.quad 0x3e4386e8a2189563							
+    .quad 0x3ff2d36390000000
+	.quad 0x3e3b19fa5d306ba7							
+    .quad 0x3ff2d73d00000000
+	.quad 0x3e6dd749b67aef76							
+    .quad 0x3ff2db14d0000000
+	.quad 0x3e676ff6f1dc04b0							
+    .quad 0x3ff2deeb20000000
+	.quad 0x3e635a33d0b232a6							
+    .quad 0x3ff2e2bfe0000000
+	.quad 0x3e64bdc80024a4e1							
+    .quad 0x3ff2e69310000000
+	.quad 0x3e6ebd61770fd723							
+    .quad 0x3ff2ea64b0000000
+	.quad 0x3e64769fc537264d							
+    .quad 0x3ff2ee34d0000000
+	.quad 0x3e69021f429f3b98							
+    .quad 0x3ff2f20360000000
+	.quad 0x3e5ee7083efbd606							
+    .quad 0x3ff2f5d070000000
+	.quad 0x3e6ad985552a6b1a							
+    .quad 0x3ff2f99bf0000000
+	.quad 0x3e6e3df778772160							
+    .quad 0x3ff2fd65f0000000
+	.quad 0x3e6ca5d76ddc9b34							
+    .quad 0x3ff3012e70000000
+	.quad 0x3e691154ffdbaf74							
+    .quad 0x3ff304f570000000
+	.quad 0x3e667bdd57fb306a							
+    .quad 0x3ff308baf0000000
+	.quad 0x3e67dc255ac40886							
+    .quad 0x3ff30c7ef0000000
+	.quad 0x3df219f38e8afafe							
+    .quad 0x3ff3104180000000
+	.quad 0x3e62416bf9669a04							
+    .quad 0x3ff3140280000000
+	.quad 0x3e611c96b2b3987f							
+    .quad 0x3ff317c210000000
+	.quad 0x3e6f99ed447e1177							
+    .quad 0x3ff31b8020000000
+	.quad 0x3e13245826328a11							
+    .quad 0x3ff31f3cd0000000
+	.quad 0x3e66f56dd1e645f8							
+    .quad 0x3ff322f7f0000000
+	.quad 0x3e46164946945535							
+    .quad 0x3ff326b1b0000000
+	.quad 0x3e5e37d59d190028							
+    .quad 0x3ff32a69f0000000
+	.quad 0x3e668671f12bf828							
+    .quad 0x3ff32e20c0000000
+	.quad 0x3e6e8ecbca6aabbd							
+    .quad 0x3ff331d620000000
+	.quad 0x3e53f49e109a5912							
+    .quad 0x3ff3358a20000000
+	.quad 0x3e6b8a0e11ec3043							
+    .quad 0x3ff3393ca0000000
+	.quad 0x3e65fae00aed691a							
+    .quad 0x3ff33cedc0000000
+	.quad 0x3e6c0569bece3e4a							
+    .quad 0x3ff3409d70000000
+	.quad 0x3e605e26744efbfe							
+    .quad 0x3ff3444bc0000000
+	.quad 0x3e65b570a94be5c5							
+    .quad 0x3ff347f8a0000000
+	.quad 0x3e5d6f156ea0e063							
+    .quad 0x3ff34ba420000000
+	.quad 0x3e6e0ca7612fc484							
+    .quad 0x3ff34f4e30000000
+	.quad 0x3e4963c927b25258							
+    .quad 0x3ff352f6f0000000
+	.quad 0x3e547930aa725a5c							
+    .quad 0x3ff3569e40000000
+	.quad 0x3e58a79fe3af43b3							
+    .quad 0x3ff35a4430000000
+	.quad 0x3e5e6dc29c41bdaf							
+    .quad 0x3ff35de8c0000000
+	.quad 0x3e657a2e76f863a5							
+    .quad 0x3ff3618bf0000000
+	.quad 0x3e2ae3b61716354d							
+    .quad 0x3ff3652dd0000000
+	.quad 0x3e665fb5df6906b1							
+    .quad 0x3ff368ce40000000
+	.quad 0x3e66177d7f588f7b							
+    .quad 0x3ff36c6d60000000
+	.quad 0x3e3ad55abd091b67							
+    .quad 0x3ff3700b30000000
+	.quad 0x3e155337b2422d76							
+    .quad 0x3ff373a7a0000000
+	.quad 0x3e6084ebe86972d5							
+    .quad 0x3ff37742b0000000
+	.quad 0x3e656395808e1ea3							
+    .quad 0x3ff37adc70000000
+	.quad 0x3e61bce21b40fba7							
+    .quad 0x3ff37e74e0000000
+	.quad 0x3e5006f94605b515							
+    .quad 0x3ff3820c00000000
+	.quad 0x3e6aa676aceb1f7d							
+    .quad 0x3ff385a1c0000000
+	.quad 0x3e58229f76554ce6							
+    .quad 0x3ff3893640000000
+	.quad 0x3e6eabfc6cf57330							
+    .quad 0x3ff38cc960000000
+	.quad 0x3e64daed9c0ce8bc							
+    .quad 0x3ff3905b40000000
+	.quad 0x3e60ff1768237141							
+    .quad 0x3ff393ebd0000000
+	.quad 0x3e6575f83051b085							
+    .quad 0x3ff3977b10000000
+	.quad 0x3e42667deb523e29							
+    .quad 0x3ff39b0910000000
+	.quad 0x3e1816996954f4fd							
+    .quad 0x3ff39e95c0000000
+	.quad 0x3e587cfccf4d9cd4							
+    .quad 0x3ff3a22120000000
+	.quad 0x3e52c5d018198353							
+    .quad 0x3ff3a5ab40000000
+	.quad 0x3e6a7a898dcc34aa							
+    .quad 0x3ff3a93410000000
+	.quad 0x3e2cead6dadc36d1							
+    .quad 0x3ff3acbbb0000000
+	.quad 0x3e2a55759c498bdf							
+    .quad 0x3ff3b04200000000
+	.quad 0x3e6c414a9ef6de04							
+    .quad 0x3ff3b3c700000000
+	.quad 0x3e63e2108a6e58fa							
+    .quad 0x3ff3b74ad0000000
+	.quad 0x3e5587fd7643d77c							
+    .quad 0x3ff3bacd60000000
+	.quad 0x3e3901eb1d3ff3df							
+    .quad 0x3ff3be4eb0000000
+	.quad 0x3e6f2ccd7c812fc6							
+    .quad 0x3ff3c1ceb0000000
+	.quad 0x3e21c8ee70a01049							
+    .quad 0x3ff3c54d90000000
+	.quad 0x3e563e8d02831eec							
+    .quad 0x3ff3c8cb20000000
+	.quad 0x3e6f61a42a92c7ff
+    .quad 0x3ff3cc4770000000
+	.quad 0x3dda917399c84d24
+    .quad 0x3ff3cfc2a0000000
+	.quad 0x3e5e9197c8eec2f0
+    .quad 0x3ff3d33c80000000
+	.quad 0x3e5e6f842f5a1378
+    .quad 0x3ff3d6b530000000
+	.quad 0x3e2fac242a90a0fc	
+    .quad 0x3ff3da2cb0000000
+	.quad 0x3e535ed726610227
+    .quad 0x3ff3dda2f0000000
+	.quad 0x3e50e0d64804b15b							
+    .quad 0x3ff3e11800000000
+	.quad 0x3e0560675daba814
+    .quad 0x3ff3e48be0000000
+	.quad 0x3e637388c8768032
+    .quad 0x3ff3e7fe80000000
+	.quad 0x3e3ee3c89f9e01f5
+    .quad 0x3ff3eb7000000000
+	.quad 0x3e639f6f0d09747c
+    .quad 0x3ff3eee040000000
+	.quad 0x3e4322c327abb8f0
+    .quad 0x3ff3f24f60000000
+	.quad 0x3e6961b347c8ac80
+    .quad 0x3ff3f5bd40000000
+	.quad 0x3e63711fbbd0f118
+    .quad 0x3ff3f92a00000000
+	.quad 0x3e64fad8d7718ffb
+    .quad 0x3ff3fc9590000000
+	.quad 0x3e6fffffffffffff	
+    .quad 0x3ff3fffff0000000
+	.quad 0x3e667efa79ec35b4
+    .quad 0x3ff4036930000000
+	.quad 0x3e6a737687a254a8
+    .quad 0x3ff406d140000000
+	.quad 0x3e5bace0f87d924d
+    .quad 0x3ff40a3830000000
+	.quad 0x3e629e37c237e392
+    .quad 0x3ff40d9df0000000
+	.quad 0x3e557ce7ac3f3012
+    .quad 0x3ff4110290000000
+	.quad 0x3e682829359f8fbd	
+    .quad 0x3ff4146600000000
+	.quad 0x3e6cc9be42d14676	
+    .quad 0x3ff417c850000000
+	.quad 0x3e6a8f001c137d0b	
+    .quad 0x3ff41b2980000000
+	.quad 0x3e636127687dda05	
+    .quad 0x3ff41e8990000000
+	.quad 0x3e524dba322646f0
+    .quad 0x3ff421e880000000
+	.quad 0x3e6dc43f1ed210b4	
+    .quad 0x3ff4254640000000
+	.quad 0x3e631ae515c447bb
+    .quad 0x3ff428a2f0000000
+                         
+
+.align 32
+.L__CBRT_F_H_256:   .quad 0x3ff0000000000000
+					.quad 0x3ff0055380000000
+					.quad 0x3ff00aa390000000
+					.quad 0x3ff00ff010000000
+					.quad 0x3ff0153920000000
+					.quad 0x3ff01a7eb0000000
+					.quad 0x3ff01fc0d0000000
+					.quad 0x3ff024ff80000000
+					.quad 0x3ff02a3ad0000000
+					.quad 0x3ff02f72b0000000
+					.quad 0x3ff034a750000000
+					.quad 0x3ff039d880000000
+					.quad 0x3ff03f0670000000
+					.quad 0x3ff0443110000000
+					.quad 0x3ff0495870000000
+					.quad 0x3ff04e7c80000000
+					.quad 0x3ff0539d60000000
+					.quad 0x3ff058bb00000000
+					.quad 0x3ff05dd570000000
+					.quad 0x3ff062ecc0000000
+					.quad 0x3ff06800e0000000
+					.quad 0x3ff06d11e0000000
+					.quad 0x3ff0721fc0000000
+					.quad 0x3ff0772a80000000
+					.quad 0x3ff07c3230000000
+					.quad 0x3ff08136d0000000
+					.quad 0x3ff0863860000000
+					.quad 0x3ff08b36f0000000
+					.quad 0x3ff0903280000000
+					.quad 0x3ff0952b10000000
+					.quad 0x3ff09a20a0000000
+					.quad 0x3ff09f1340000000
+					.quad 0x3ff0a402f0000000
+					.quad 0x3ff0a8efc0000000
+					.quad 0x3ff0add990000000
+					.quad 0x3ff0b2c090000000
+					.quad 0x3ff0b7a4b0000000
+					.quad 0x3ff0bc85f0000000
+					.quad 0x3ff0c16450000000
+					.quad 0x3ff0c63fe0000000
+					.quad 0x3ff0cb18b0000000
+					.quad 0x3ff0cfeeb0000000
+					.quad 0x3ff0d4c1e0000000
+					.quad 0x3ff0d99250000000
+					.quad 0x3ff0de6010000000
+					.quad 0x3ff0e32b00000000
+					.quad 0x3ff0e7f340000000
+					.quad 0x3ff0ecb8d0000000
+					.quad 0x3ff0f17bb0000000
+					.quad 0x3ff0f63bf0000000
+					.quad 0x3ff0faf970000000
+					.quad 0x3ff0ffb460000000
+					.quad 0x3ff1046cb0000000
+					.quad 0x3ff1092250000000
+					.quad 0x3ff10dd560000000
+					.quad 0x3ff11285e0000000
+					.quad 0x3ff11733d0000000
+					.quad 0x3ff11bdf30000000
+					.quad 0x3ff1208800000000
+					.quad 0x3ff1252e40000000
+					.quad 0x3ff129d210000000
+					.quad 0x3ff12e7350000000
+					.quad 0x3ff1331210000000
+					.quad 0x3ff137ae60000000
+					.quad 0x3ff13c4840000000
+					.quad 0x3ff140dfa0000000
+					.quad 0x3ff1457490000000
+					.quad 0x3ff14a0710000000
+					.quad 0x3ff14e9730000000
+					.quad 0x3ff15324e0000000
+					.quad 0x3ff157b030000000
+					.quad 0x3ff15c3920000000
+					.quad 0x3ff160bfc0000000
+					.quad 0x3ff16543f0000000
+					.quad 0x3ff169c5d0000000
+					.quad 0x3ff16e4560000000
+					.quad 0x3ff172c2a0000000
+					.quad 0x3ff1773d90000000
+					.quad 0x3ff17bb630000000
+					.quad 0x3ff1802c90000000
+					.quad 0x3ff184a0a0000000
+					.quad 0x3ff1891270000000
+					.quad 0x3ff18d8210000000
+					.quad 0x3ff191ef60000000
+					.quad 0x3ff1965a80000000
+					.quad 0x3ff19ac360000000
+					.quad 0x3ff19f2a10000000
+					.quad 0x3ff1a38e90000000
+					.quad 0x3ff1a7f0e0000000
+					.quad 0x3ff1ac5100000000
+					.quad 0x3ff1b0af00000000
+					.quad 0x3ff1b50ad0000000
+					.quad 0x3ff1b96480000000
+					.quad 0x3ff1bdbc10000000
+					.quad 0x3ff1c21180000000
+					.quad 0x3ff1c664d0000000
+					.quad 0x3ff1cab610000000
+					.quad 0x3ff1cf0530000000
+					.quad 0x3ff1d35230000000
+					.quad 0x3ff1d79d30000000
+					.quad 0x3ff1dbe620000000
+					.quad 0x3ff1e02cf0000000
+					.quad 0x3ff1e471d0000000
+					.quad 0x3ff1e8b490000000
+					.quad 0x3ff1ecf550000000
+					.quad 0x3ff1f13410000000
+					.quad 0x3ff1f570d0000000
+					.quad 0x3ff1f9ab90000000
+					.quad 0x3ff1fde450000000
+					.quad 0x3ff2021b20000000
+					.quad 0x3ff2064ff0000000
+					.quad 0x3ff20a82c0000000
+					.quad 0x3ff20eb3b0000000
+					.quad 0x3ff212e2a0000000
+					.quad 0x3ff2170fb0000000
+					.quad 0x3ff21b3ac0000000
+					.quad 0x3ff21f63f0000000
+					.quad 0x3ff2238b40000000
+					.quad 0x3ff227b0a0000000
+					.quad 0x3ff22bd420000000
+					.quad 0x3ff22ff5c0000000
+					.quad 0x3ff2341570000000
+					.quad 0x3ff2383350000000
+					.quad 0x3ff23c4f60000000
+					.quad 0x3ff2406980000000
+					.quad 0x3ff24481d0000000
+					.quad 0x3ff2489850000000
+					.quad 0x3ff24cad00000000
+					.quad 0x3ff250bfe0000000
+					.quad 0x3ff254d0e0000000
+					.quad 0x3ff258e020000000
+					.quad 0x3ff25ced90000000
+					.quad 0x3ff260f940000000
+					.quad 0x3ff2650320000000
+					.quad 0x3ff2690b40000000
+					.quad 0x3ff26d1190000000
+					.quad 0x3ff2711630000000
+					.quad 0x3ff2751900000000
+					.quad 0x3ff2791a20000000
+					.quad 0x3ff27d1980000000
+					.quad 0x3ff2811720000000
+					.quad 0x3ff2851310000000
+					.quad 0x3ff2890d50000000
+					.quad 0x3ff28d05d0000000
+					.quad 0x3ff290fca0000000
+					.quad 0x3ff294f1c0000000
+					.quad 0x3ff298e530000000
+					.quad 0x3ff29cd700000000
+					.quad 0x3ff2a0c710000000
+					.quad 0x3ff2a4b580000000
+					.quad 0x3ff2a8a250000000
+					.quad 0x3ff2ac8d70000000
+					.quad 0x3ff2b076f0000000
+					.quad 0x3ff2b45ec0000000
+					.quad 0x3ff2b84500000000
+					.quad 0x3ff2bc29a0000000
+					.quad 0x3ff2c00c90000000
+					.quad 0x3ff2c3ee00000000
+					.quad 0x3ff2c7cdc0000000
+					.quad 0x3ff2cbabf0000000
+					.quad 0x3ff2cf8880000000
+					.quad 0x3ff2d36390000000
+					.quad 0x3ff2d73d00000000
+					.quad 0x3ff2db14d0000000
+					.quad 0x3ff2deeb20000000
+					.quad 0x3ff2e2bfe0000000
+					.quad 0x3ff2e69310000000
+					.quad 0x3ff2ea64b0000000
+					.quad 0x3ff2ee34d0000000
+					.quad 0x3ff2f20360000000
+					.quad 0x3ff2f5d070000000
+					.quad 0x3ff2f99bf0000000
+					.quad 0x3ff2fd65f0000000
+					.quad 0x3ff3012e70000000
+					.quad 0x3ff304f570000000
+					.quad 0x3ff308baf0000000
+					.quad 0x3ff30c7ef0000000
+					.quad 0x3ff3104180000000
+					.quad 0x3ff3140280000000
+					.quad 0x3ff317c210000000
+					.quad 0x3ff31b8020000000
+					.quad 0x3ff31f3cd0000000
+					.quad 0x3ff322f7f0000000
+					.quad 0x3ff326b1b0000000
+					.quad 0x3ff32a69f0000000
+					.quad 0x3ff32e20c0000000
+					.quad 0x3ff331d620000000
+					.quad 0x3ff3358a20000000
+					.quad 0x3ff3393ca0000000
+					.quad 0x3ff33cedc0000000
+					.quad 0x3ff3409d70000000
+					.quad 0x3ff3444bc0000000
+					.quad 0x3ff347f8a0000000
+					.quad 0x3ff34ba420000000
+					.quad 0x3ff34f4e30000000
+					.quad 0x3ff352f6f0000000
+					.quad 0x3ff3569e40000000
+					.quad 0x3ff35a4430000000
+					.quad 0x3ff35de8c0000000
+					.quad 0x3ff3618bf0000000
+					.quad 0x3ff3652dd0000000
+					.quad 0x3ff368ce40000000
+					.quad 0x3ff36c6d60000000
+					.quad 0x3ff3700b30000000
+					.quad 0x3ff373a7a0000000
+					.quad 0x3ff37742b0000000
+					.quad 0x3ff37adc70000000
+					.quad 0x3ff37e74e0000000
+					.quad 0x3ff3820c00000000
+					.quad 0x3ff385a1c0000000
+					.quad 0x3ff3893640000000
+					.quad 0x3ff38cc960000000
+					.quad 0x3ff3905b40000000
+					.quad 0x3ff393ebd0000000
+					.quad 0x3ff3977b10000000
+					.quad 0x3ff39b0910000000
+					.quad 0x3ff39e95c0000000
+					.quad 0x3ff3a22120000000
+					.quad 0x3ff3a5ab40000000
+					.quad 0x3ff3a93410000000
+					.quad 0x3ff3acbbb0000000
+					.quad 0x3ff3b04200000000
+					.quad 0x3ff3b3c700000000
+					.quad 0x3ff3b74ad0000000
+					.quad 0x3ff3bacd60000000
+					.quad 0x3ff3be4eb0000000
+					.quad 0x3ff3c1ceb0000000
+					.quad 0x3ff3c54d90000000
+					.quad 0x3ff3c8cb20000000
+					.quad 0x3ff3cc4770000000
+					.quad 0x3ff3cfc2a0000000
+					.quad 0x3ff3d33c80000000
+					.quad 0x3ff3d6b530000000
+					.quad 0x3ff3da2cb0000000
+					.quad 0x3ff3dda2f0000000
+					.quad 0x3ff3e11800000000
+					.quad 0x3ff3e48be0000000
+					.quad 0x3ff3e7fe80000000
+					.quad 0x3ff3eb7000000000
+					.quad 0x3ff3eee040000000
+					.quad 0x3ff3f24f60000000
+					.quad 0x3ff3f5bd40000000
+					.quad 0x3ff3f92a00000000
+					.quad 0x3ff3fc9590000000
+					.quad 0x3ff3fffff0000000
+					.quad 0x3ff4036930000000
+					.quad 0x3ff406d140000000
+					.quad 0x3ff40a3830000000
+					.quad 0x3ff40d9df0000000
+					.quad 0x3ff4110290000000
+					.quad 0x3ff4146600000000
+					.quad 0x3ff417c850000000
+					.quad 0x3ff41b2980000000
+					.quad 0x3ff41e8990000000
+					.quad 0x3ff421e880000000
+					.quad 0x3ff4254640000000
+
+.align 32
+.L__CBRT_F_T_256:	.quad 0x0000000000000000
+					.quad 0x3e6e6a24c81e4294
+					.quad 0x3e58548511e3a785
+					.quad 0x3e64eb9336ec07f6
+					.quad 0x3e40ea64b8b750e1
+					.quad 0x3e461637cff8a53c
+					.quad 0x3e40733bf7bd1943
+					.quad 0x3e5666911345cced
+					.quad 0x3e477b7a3f592f14
+					.quad 0x3e6f18d3dd1a5402
+					.quad 0x3e2be2f5a58ee9a4
+					.quad 0x3e68901f8f085fa7
+					.quad 0x3e5c68b8cd5b5d69
+					.quad 0x3e5a6b0e8624be42
+					.quad 0x3dbc4b22b06f68e7
+					.quad 0x3e60f3f0afcabe9b
+					.quad 0x3e548495bca4e1b7
+					.quad 0x3e66107f1abdfdc3
+					.quad 0x3e6e67261878288a
+					.quad 0x3e5a6bc155286f1e
+					.quad 0x3e58a759c64a85f2
+					.quad 0x3e45fce70a4a8d09
+					.quad 0x3e32f9cbf373fe1d
+					.quad 0x3e590564ce4ac359
+					.quad 0x3e5ac29ce761b02f
+					.quad 0x3e5cb752f497381c
+					.quad 0x3e68bb9e1cfb35e0
+					.quad 0x3e65b4917099de90
+					.quad 0x3e5cc77ac9c65ef2
+					.quad 0x3e57a0f3e7be3dba
+					.quad 0x3e66ec851ee0c16f
+					.quad 0x3e689449bf2946da
+					.quad 0x3e698f25301ba223
+					.quad 0x3e347d5ec651f549
+					.quad 0x3e6c33ec9a86007a
+					.quad 0x3e5e0b6653e92649
+					.quad 0x3e3bd64ac09d755f
+					.quad 0x3e2f537506f78167
+					.quad 0x3e62c382d1b3735e
+					.quad 0x3e6e20ed659f99e1
+					.quad 0x3e586b633a9c182a
+					.quad 0x3e445cfd5a65e777
+					.quad 0x3e60c8770f58bca4
+					.quad 0x3e6739e44b0933c5
+					.quad 0x3e027dc3d9ce7bd8
+					.quad 0x3e63c53c7c5a7b64
+					.quad 0x3e69669683830cec
+					.quad 0x3e68d772c39bdcc4
+					.quad 0x3e69b0008bcf6d7b
+					.quad 0x3e3bbb305825ce4f
+					.quad 0x3e6da3f4af13a406
+					.quad 0x3e5f36b96f74ce86
+					.quad 0x3e165c002303f790
+					.quad 0x3e682f84095ba7d5
+					.quad 0x3e6d46433541b2c6
+					.quad 0x3e671c3d56e93a89
+					.quad 0x3e598dcef4e40012
+					.quad 0x3e4530ebef17fe03
+					.quad 0x3e4e8b8fa3715066
+					.quad 0x3e6ab26eb3b211dc
+					.quad 0x3e454dd4dc906307
+					.quad 0x3e5c9f962387984e
+					.quad 0x3e6c62a959afec09
+					.quad 0x3e6638d9ac6a866a
+					.quad 0x3e338704eca8a22d
+					.quad 0x3e4e6c9e1db14f8f
+					.quad 0x3e58744b7f9c9eaa
+					.quad 0x3e66c2893486373b
+					.quad 0x3e5b36bce31699b7
+					.quad 0x3e671e3813d200c7
+					.quad 0x3e699755ab40aa88
+					.quad 0x3e6b45ca0e4bcfc0
+					.quad 0x3e32dd090d869c5d
+					.quad 0x3e64fe0516b917da
+					.quad 0x3e694563226317a2
+					.quad 0x3e653d8fafc2c851
+					.quad 0x3e5dcbd41fbd41a3
+					.quad 0x3e5862ff5285f59c
+					.quad 0x3e63072ea97a1e1c
+					.quad 0x3e52839075184805
+					.quad 0x3e64b0323e9eff42
+					.quad 0x3e6b158893c45484
+					.quad 0x3e3149ef0fc35826
+					.quad 0x3e5f2e77ea96acaa
+					.quad 0x3e5200074c471a95
+					.quad 0x3e63f8cc517f6f04
+					.quad 0x3e660ba2e311bb55
+					.quad 0x3e64b788730bbec3
+					.quad 0x3e657090795ee20c
+					.quad 0x3e6d9ffe983670b1
+					.quad 0x3e62a463ff61bfda
+					.quad 0x3e69d1bc6a5e65cf
+					.quad 0x3e68718abaa9e922
+					.quad 0x3e63c2f52ffa342e
+					.quad 0x3e60fae13ff42c80
+					.quad 0x3e65440f0ef00d57
+					.quad 0x3e46fcd22d4e3c1e
+					.quad 0x3e4e0c60b409e863
+					.quad 0x3e6f9cab5a5f0333
+					.quad 0x3e630f24744c333d
+					.quad 0x3e4b50622a76b2fe
+					.quad 0x3e6fdb94ba595375
+					.quad 0x3e3861b9b945a171
+					.quad 0x3e654348015188c4
+					.quad 0x3e6b54d149865523
+					.quad 0x3e6a0bb783d9de33
+					.quad 0x3e6629d12b1a2157
+					.quad 0x3e6467fe35d179df
+					.quad 0x3e69763f3e26c8f7
+					.quad 0x3e53f798bb9f7679
+					.quad 0x3e552e577e855898
+					.quad 0x3e6fde47e5502c3a
+					.quad 0x3e5cbd0b548d96a0
+					.quad 0x3e6a9cd9f7be8de8
+					.quad 0x3e522bbe704886de
+					.quad 0x3e6e3dea8317f020
+					.quad 0x3e6e812085ac8855
+					.quad 0x3e5c87144f24cb07
+					.quad 0x3e61e128ee311fa2
+					.quad 0x3e5b5c163d61a2d3
+					.quad 0x3e47d97e7fb90633
+					.quad 0x3e6efe899d50f6a7
+					.quad 0x3e6d0333eb75de5a
+					.quad 0x3e40e590be73a573
+					.quad 0x3e68ce8dcac3cdd2
+					.quad 0x3e6ee8a48954064b
+					.quad 0x3e6aa62f18461e09
+					.quad 0x3e601e5940986a15
+					.quad 0x3e3b082f4f9b8d4c
+					.quad 0x3e6876e0e5527f5a
+					.quad 0x3e63617080831e6b
+					.quad 0x3e681b26e34aa4a2
+					.quad 0x3e552ee66dfab0c1
+					.quad 0x3e5d85a5329e8819
+					.quad 0x3e5105c1b646b5d1
+					.quad 0x3e6bb6690c1a379c
+					.quad 0x3e586aeba73ce3a9
+					.quad 0x3e6dd16198294dd4
+					.quad 0x3e6454e675775e83
+					.quad 0x3e63842e026197ea
+					.quad 0x3e6f1ce0e70c44d2
+					.quad 0x3e6ad636441a5627
+					.quad 0x3e54c205d7212abb
+					.quad 0x3e6167c86c116419
+					.quad 0x3e638ec3ef16e294
+					.quad 0x3e6473fceace9321
+					.quad 0x3e67af53a836dba7
+					.quad 0x3e1a51f3c383b652
+					.quad 0x3e63696da190822d
+					.quad 0x3e62f9adec77074b
+					.quad 0x3e38190fd5bee55f
+					.quad 0x3e4bfee8fac68e55
+					.quad 0x3e331c9d6bc5f68a
+					.quad 0x3e689d0523737edf
+					.quad 0x3e5a295943bf47bb
+					.quad 0x3e396be32e5b3207
+					.quad 0x3e6e44c7d909fa0e
+					.quad 0x3e2b2505da94d9ea
+					.quad 0x3e60c851f46c9c98
+					.quad 0x3e5da71f7d9aa3b7
+					.quad 0x3e6f1b605d019ef1
+					.quad 0x3e4386e8a2189563
+					.quad 0x3e3b19fa5d306ba7
+					.quad 0x3e6dd749b67aef76
+					.quad 0x3e676ff6f1dc04b0
+					.quad 0x3e635a33d0b232a6
+					.quad 0x3e64bdc80024a4e1
+					.quad 0x3e6ebd61770fd723
+					.quad 0x3e64769fc537264d
+					.quad 0x3e69021f429f3b98
+					.quad 0x3e5ee7083efbd606
+					.quad 0x3e6ad985552a6b1a
+					.quad 0x3e6e3df778772160
+					.quad 0x3e6ca5d76ddc9b34
+					.quad 0x3e691154ffdbaf74
+					.quad 0x3e667bdd57fb306a
+					.quad 0x3e67dc255ac40886
+					.quad 0x3df219f38e8afafe
+					.quad 0x3e62416bf9669a04
+					.quad 0x3e611c96b2b3987f
+					.quad 0x3e6f99ed447e1177
+					.quad 0x3e13245826328a11
+					.quad 0x3e66f56dd1e645f8
+					.quad 0x3e46164946945535
+					.quad 0x3e5e37d59d190028
+					.quad 0x3e668671f12bf828
+					.quad 0x3e6e8ecbca6aabbd
+					.quad 0x3e53f49e109a5912
+					.quad 0x3e6b8a0e11ec3043
+					.quad 0x3e65fae00aed691a
+					.quad 0x3e6c0569bece3e4a
+					.quad 0x3e605e26744efbfe
+					.quad 0x3e65b570a94be5c5
+					.quad 0x3e5d6f156ea0e063
+					.quad 0x3e6e0ca7612fc484
+					.quad 0x3e4963c927b25258
+					.quad 0x3e547930aa725a5c
+					.quad 0x3e58a79fe3af43b3
+					.quad 0x3e5e6dc29c41bdaf
+					.quad 0x3e657a2e76f863a5
+					.quad 0x3e2ae3b61716354d
+					.quad 0x3e665fb5df6906b1
+					.quad 0x3e66177d7f588f7b
+					.quad 0x3e3ad55abd091b67
+					.quad 0x3e155337b2422d76
+					.quad 0x3e6084ebe86972d5
+					.quad 0x3e656395808e1ea3
+					.quad 0x3e61bce21b40fba7
+					.quad 0x3e5006f94605b515
+					.quad 0x3e6aa676aceb1f7d
+					.quad 0x3e58229f76554ce6
+					.quad 0x3e6eabfc6cf57330
+					.quad 0x3e64daed9c0ce8bc
+					.quad 0x3e60ff1768237141
+					.quad 0x3e6575f83051b085
+					.quad 0x3e42667deb523e29
+					.quad 0x3e1816996954f4fd
+					.quad 0x3e587cfccf4d9cd4
+					.quad 0x3e52c5d018198353
+					.quad 0x3e6a7a898dcc34aa
+					.quad 0x3e2cead6dadc36d1
+					.quad 0x3e2a55759c498bdf
+					.quad 0x3e6c414a9ef6de04
+					.quad 0x3e63e2108a6e58fa
+					.quad 0x3e5587fd7643d77c
+					.quad 0x3e3901eb1d3ff3df
+					.quad 0x3e6f2ccd7c812fc6
+					.quad 0x3e21c8ee70a01049
+					.quad 0x3e563e8d02831eec
+					.quad 0x3e6f61a42a92c7ff
+					.quad 0x3dda917399c84d24
+					.quad 0x3e5e9197c8eec2f0
+					.quad 0x3e5e6f842f5a1378
+					.quad 0x3e2fac242a90a0fc
+					.quad 0x3e535ed726610227
+					.quad 0x3e50e0d64804b15b
+					.quad 0x3e0560675daba814
+					.quad 0x3e637388c8768032
+					.quad 0x3e3ee3c89f9e01f5
+					.quad 0x3e639f6f0d09747c
+					.quad 0x3e4322c327abb8f0
+					.quad 0x3e6961b347c8ac80
+					.quad 0x3e63711fbbd0f118
+					.quad 0x3e64fad8d7718ffb
+					.quad 0x3e6fffffffffffff
+					.quad 0x3e667efa79ec35b4
+					.quad 0x3e6a737687a254a8
+					.quad 0x3e5bace0f87d924d
+					.quad 0x3e629e37c237e392
+					.quad 0x3e557ce7ac3f3012
+					.quad 0x3e682829359f8fbd
+					.quad 0x3e6cc9be42d14676
+					.quad 0x3e6a8f001c137d0b
+					.quad 0x3e636127687dda05
+					.quad 0x3e524dba322646f0
+					.quad 0x3e6dc43f1ed210b4
+
+.align 32
+.L__INV_TAB_256:    .quad 0x4000000000000000
+					.quad 0x3fffe01fe01fe020
+					.quad 0x3fffc07f01fc07f0
+					.quad 0x3fffa11caa01fa12
+					.quad 0x3fff81f81f81f820
+					.quad 0x3fff6310aca0dbb5
+					.quad 0x3fff44659e4a4271
+					.quad 0x3fff25f644230ab5
+					.quad 0x3fff07c1f07c1f08
+					.quad 0x3ffee9c7f8458e02
+					.quad 0x3ffecc07b301ecc0
+					.quad 0x3ffeae807aba01eb
+					.quad 0x3ffe9131abf0b767
+					.quad 0x3ffe741aa59750e4
+					.quad 0x3ffe573ac901e574
+					.quad 0x3ffe3a9179dc1a73
+					.quad 0x3ffe1e1e1e1e1e1e
+					.quad 0x3ffe01e01e01e01e
+					.quad 0x3ffde5d6e3f8868a
+					.quad 0x3ffdca01dca01dca
+					.quad 0x3ffdae6076b981db
+					.quad 0x3ffd92f2231e7f8a
+					.quad 0x3ffd77b654b82c34
+					.quad 0x3ffd5cac807572b2
+					.quad 0x3ffd41d41d41d41d
+					.quad 0x3ffd272ca3fc5b1a
+					.quad 0x3ffd0cb58f6ec074
+					.quad 0x3ffcf26e5c44bfc6
+					.quad 0x3ffcd85689039b0b
+					.quad 0x3ffcbe6d9601cbe7
+					.quad 0x3ffca4b3055ee191
+					.quad 0x3ffc8b265afb8a42
+					.quad 0x3ffc71c71c71c71c
+					.quad 0x3ffc5894d10d4986
+					.quad 0x3ffc3f8f01c3f8f0
+					.quad 0x3ffc26b5392ea01c
+					.quad 0x3ffc0e070381c0e0
+					.quad 0x3ffbf583ee868d8b
+					.quad 0x3ffbdd2b899406f7
+					.quad 0x3ffbc4fd65883e7b
+					.quad 0x3ffbacf914c1bad0
+					.quad 0x3ffb951e2b18ff23
+					.quad 0x3ffb7d6c3dda338b
+					.quad 0x3ffb65e2e3beee05
+					.quad 0x3ffb4e81b4e81b4f
+					.quad 0x3ffb37484ad806ce
+					.quad 0x3ffb2036406c80d9
+					.quad 0x3ffb094b31d922a4
+					.quad 0x3ffaf286bca1af28
+					.quad 0x3ffadbe87f94905e
+					.quad 0x3ffac5701ac5701b
+					.quad 0x3ffaaf1d2f87ebfd
+					.quad 0x3ffa98ef606a63be
+					.quad 0x3ffa82e65130e159
+					.quad 0x3ffa6d01a6d01a6d
+					.quad 0x3ffa574107688a4a
+					.quad 0x3ffa41a41a41a41a
+					.quad 0x3ffa2c2a87c51ca0
+					.quad 0x3ffa16d3f97a4b02
+					.quad 0x3ffa01a01a01a01a
+					.quad 0x3ff9ec8e951033d9
+					.quad 0x3ff9d79f176b682d
+					.quad 0x3ff9c2d14ee4a102
+					.quad 0x3ff9ae24ea5510da
+					.quad 0x3ff999999999999a
+					.quad 0x3ff9852f0d8ec0ff
+					.quad 0x3ff970e4f80cb872
+					.quad 0x3ff95cbb0be377ae
+					.quad 0x3ff948b0fcd6e9e0
+					.quad 0x3ff934c67f9b2ce6
+					.quad 0x3ff920fb49d0e229
+					.quad 0x3ff90d4f120190d5
+					.quad 0x3ff8f9c18f9c18fa
+					.quad 0x3ff8e6527af1373f
+					.quad 0x3ff8d3018d3018d3
+					.quad 0x3ff8bfce8062ff3a
+					.quad 0x3ff8acb90f6bf3aa
+					.quad 0x3ff899c0f601899c
+					.quad 0x3ff886e5f0abb04a
+					.quad 0x3ff87427bcc092b9
+					.quad 0x3ff8618618618618
+					.quad 0x3ff84f00c2780614
+					.quad 0x3ff83c977ab2bedd
+					.quad 0x3ff82a4a0182a4a0
+					.quad 0x3ff8181818181818
+					.quad 0x3ff8060180601806
+					.quad 0x3ff7f405fd017f40
+					.quad 0x3ff7e225515a4f1d
+					.quad 0x3ff7d05f417d05f4
+					.quad 0x3ff7beb3922e017c
+					.quad 0x3ff7ad2208e0ecc3
+					.quad 0x3ff79baa6bb6398b
+					.quad 0x3ff78a4c8178a4c8
+					.quad 0x3ff77908119ac60d
+					.quad 0x3ff767dce434a9b1
+					.quad 0x3ff756cac201756d
+					.quad 0x3ff745d1745d1746
+					.quad 0x3ff734f0c541fe8d
+					.quad 0x3ff724287f46debc
+					.quad 0x3ff713786d9c7c09
+					.quad 0x3ff702e05c0b8170
+					.quad 0x3ff6f26016f26017
+					.quad 0x3ff6e1f76b4337c7
+					.quad 0x3ff6d1a62681c861
+					.quad 0x3ff6c16c16c16c17
+					.quad 0x3ff6b1490aa31a3d
+					.quad 0x3ff6a13cd1537290
+					.quad 0x3ff691473a88d0c0
+					.quad 0x3ff6816816816817
+					.quad 0x3ff6719f3601671a
+					.quad 0x3ff661ec6a5122f9
+					.quad 0x3ff6524f853b4aa3
+					.quad 0x3ff642c8590b2164
+					.quad 0x3ff63356b88ac0de
+					.quad 0x3ff623fa77016240
+					.quad 0x3ff614b36831ae94
+					.quad 0x3ff6058160581606
+					.quad 0x3ff5f66434292dfc
+					.quad 0x3ff5e75bb8d015e7
+					.quad 0x3ff5d867c3ece2a5
+					.quad 0x3ff5c9882b931057
+					.quad 0x3ff5babcc647fa91
+					.quad 0x3ff5ac056b015ac0
+					.quad 0x3ff59d61f123ccaa
+					.quad 0x3ff58ed2308158ed
+					.quad 0x3ff5805601580560
+					.quad 0x3ff571ed3c506b3a
+					.quad 0x3ff56397ba7c52e2
+					.quad 0x3ff5555555555555
+					.quad 0x3ff54725e6bb82fe
+					.quad 0x3ff5390948f40feb
+					.quad 0x3ff52aff56a8054b
+					.quad 0x3ff51d07eae2f815
+					.quad 0x3ff50f22e111c4c5
+					.quad 0x3ff5015015015015
+					.quad 0x3ff4f38f62dd4c9b
+					.quad 0x3ff4e5e0a72f0539
+					.quad 0x3ff4d843bedc2c4c
+					.quad 0x3ff4cab88725af6e
+					.quad 0x3ff4bd3edda68fe1
+					.quad 0x3ff4afd6a052bf5b
+					.quad 0x3ff4a27fad76014a
+					.quad 0x3ff49539e3b2d067
+					.quad 0x3ff4880522014880
+					.quad 0x3ff47ae147ae147b
+					.quad 0x3ff46dce34596066
+					.quad 0x3ff460cbc7f5cf9a
+					.quad 0x3ff453d9e2c776ca
+					.quad 0x3ff446f86562d9fb
+					.quad 0x3ff43a2730abee4d
+					.quad 0x3ff42d6625d51f87
+					.quad 0x3ff420b5265e5951
+					.quad 0x3ff4141414141414
+					.quad 0x3ff40782d10e6566
+					.quad 0x3ff3fb013fb013fb
+					.quad 0x3ff3ee8f42a5af07
+					.quad 0x3ff3e22cbce4a902
+					.quad 0x3ff3d5d991aa75c6
+					.quad 0x3ff3c995a47babe7
+					.quad 0x3ff3bd60d9232955
+					.quad 0x3ff3b13b13b13b14
+					.quad 0x3ff3a524387ac822
+					.quad 0x3ff3991c2c187f63
+					.quad 0x3ff38d22d366088e
+					.quad 0x3ff3813813813814
+					.quad 0x3ff3755bd1c945ee
+					.quad 0x3ff3698df3de0748
+					.quad 0x3ff35dce5f9f2af8
+					.quad 0x3ff3521cfb2b78c1
+					.quad 0x3ff34679ace01346
+					.quad 0x3ff33ae45b57bcb2
+					.quad 0x3ff32f5ced6a1dfa
+					.quad 0x3ff323e34a2b10bf
+					.quad 0x3ff3187758e9ebb6
+					.quad 0x3ff30d190130d190
+					.quad 0x3ff301c82ac40260
+					.quad 0x3ff2f684bda12f68
+					.quad 0x3ff2eb4ea1fed14b
+					.quad 0x3ff2e025c04b8097
+					.quad 0x3ff2d50a012d50a0
+					.quad 0x3ff2c9fb4d812ca0
+					.quad 0x3ff2bef98e5a3711
+					.quad 0x3ff2b404ad012b40
+					.quad 0x3ff2a91c92f3c105
+					.quad 0x3ff29e4129e4129e
+					.quad 0x3ff293725bb804a5
+					.quad 0x3ff288b01288b013
+					.quad 0x3ff27dfa38a1ce4d
+					.quad 0x3ff27350b8812735
+					.quad 0x3ff268b37cd60127
+					.quad 0x3ff25e22708092f1
+					.quad 0x3ff2539d7e9177b2
+					.quad 0x3ff2492492492492
+					.quad 0x3ff23eb79717605b
+					.quad 0x3ff23456789abcdf
+					.quad 0x3ff22a0122a0122a
+					.quad 0x3ff21fb78121fb78
+					.quad 0x3ff21579804855e6
+					.quad 0x3ff20b470c67c0d9
+					.quad 0x3ff2012012012012
+					.quad 0x3ff1f7047dc11f70
+					.quad 0x3ff1ecf43c7fb84c
+					.quad 0x3ff1e2ef3b3fb874
+					.quad 0x3ff1d8f5672e4abd
+					.quad 0x3ff1cf06ada2811d
+					.quad 0x3ff1c522fc1ce059
+					.quad 0x3ff1bb4a4046ed29
+					.quad 0x3ff1b17c67f2bae3
+					.quad 0x3ff1a7b9611a7b96
+					.quad 0x3ff19e0119e0119e
+					.quad 0x3ff19453808ca29c
+					.quad 0x3ff18ab083902bdb
+					.quad 0x3ff1811811811812
+					.quad 0x3ff1778a191bd684
+					.quad 0x3ff16e0689427379
+					.quad 0x3ff1648d50fc3201
+					.quad 0x3ff15b1e5f75270d
+					.quad 0x3ff151b9a3fdd5c9
+					.quad 0x3ff1485f0e0acd3b
+					.quad 0x3ff13f0e8d344724
+					.quad 0x3ff135c81135c811
+					.quad 0x3ff12c8b89edc0ac
+					.quad 0x3ff12358e75d3033
+					.quad 0x3ff11a3019a74826
+					.quad 0x3ff1111111111111
+					.quad 0x3ff107fbbe011080
+					.quad 0x3ff0fef010fef011
+					.quad 0x3ff0f5edfab325a2
+					.quad 0x3ff0ecf56be69c90
+					.quad 0x3ff0e40655826011
+					.quad 0x3ff0db20a88f4696
+					.quad 0x3ff0d24456359e3a
+					.quad 0x3ff0c9714fbcda3b
+					.quad 0x3ff0c0a7868b4171
+					.quad 0x3ff0b7e6ec259dc8
+					.quad 0x3ff0af2f722eecb5
+					.quad 0x3ff0a6810a6810a7
+					.quad 0x3ff09ddba6af8360
+					.quad 0x3ff0953f39010954
+					.quad 0x3ff08cabb37565e2
+					.quad 0x3ff0842108421084
+					.quad 0x3ff07b9f29b8eae2
+					.quad 0x3ff073260a47f7c6
+					.quad 0x3ff06ab59c7912fb
+					.quad 0x3ff0624dd2f1a9fc
+					.quad 0x3ff059eea0727586
+					.quad 0x3ff05197f7d73404
+					.quad 0x3ff04949cc1664c5
+					.quad 0x3ff0410410410410
+					.quad 0x3ff038c6b78247fc
+					.quad 0x3ff03091b51f5e1a
+					.quad 0x3ff02864fc7729e9
+					.quad 0x3ff0204081020408
+					.quad 0x3ff0182436517a37
+					.quad 0x3ff0101010101010
+					.quad 0x3ff0080402010080
+					.quad 0x3ff0000000000000
+
diff --git a/src/gas/cbrtf.S b/src/gas/cbrtf.S
new file mode 100644
index 0000000..21bdd0b
--- /dev/null
+++ b/src/gas/cbrtf.S
@@ -0,0 +1,717 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+# cbrtf.S
+#
+# An implementation of the cbrtf libm function.
+#
+# Prototype:
+#
+#     float cbrtf(float x);
+#
+
+#
+#   Algorithm:
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(cbrtf)
+#define fname_special _cbrtf_special
+
+
+# local variable storage offsets
+
+.equ   store_input, 0x0 
+.equ   stack_size, 0x20 
+
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 32
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+    xor   %rcx,%rcx
+    sub   $stack_size, %rsp
+    movss %xmm0, store_input(%rsp)
+    movss %xmm0,%xmm1
+    mov   store_input(%rsp),%r8
+    mov   $0x7F800000,%r10
+    mov   $0x007FFFFF,%r11
+    mov   %r8,%r9
+    and   %r10,%r8 # r8 = stores the exponent
+    and   %r11,%r9 # r9 = stores the mantissa
+    cmp   $0X7F800000,%r8
+    jz    .L__cbrtf_is_nan_infinite
+    cmp   $0X0,%r8
+    jz    .L__cbrtf_is_denormal
+.align 32
+.L__cbrtf_is_normal:   
+    cvtps2pd %xmm1,%xmm1
+    shr   $23,%r8  # exp value
+    mov   $3,%rdx # check whether always dx is set to 3
+    mov   %r8,%rax
+    movsd %xmm1,%xmm6
+    shr   $15,%r9  # index for the reciprocal
+    sub   $0x7F,%ax
+    idiv  %dl # Accumulator is divided by dl=3
+    mov   %ax,%dx
+    shr   $8,%dx #dx = Contains the remainder
+    add   $2,%dl
+                 #ax = Contains the quotient, Scale factor
+    cbw          # sign extend al to ax
+    add   $0x3FF,%ax
+    shl   $52,%rax
+    pand .L__mantissa_mask_64(%rip),%xmm1    
+    mov   %rax,store_input(%rsp)
+    movsd store_input(%rsp),%xmm7
+    movsd  .L__sign_mask_64(%rip),%xmm2
+    por .L__one_mask_64(%rip),%xmm1
+    movapd .L__coefficients(%rip),%xmm0
+    pandn %xmm1,%xmm2
+    pand  .L__sign_mask_64(%rip),%xmm6 # has the sign
+    lea .L__DoubleReciprocalTable_256(%rip),%r8
+    lea .L__CubeRootTable_256(%rip),%rax
+    movsd (%r8,%r9,8),%xmm3#reciprocal, Size of double is 8
+    movsd (%rax,%r9,8),%xmm4#cuberoot
+    mulsd %xmm2,%xmm3
+    subsd .L__one_mask_64(%rip),%xmm3
+    
+    # movddup %xmm3,%xmm3
+    shufpd $0,%xmm3,%xmm3 # replacing movddup
+    
+    mulsd %xmm3,%xmm3
+    mulpd %xmm3,%xmm0
+#######################################################################    
+#haddpd is an SSE3 instruction On using this instruction it gives a better performance    
+    #haddpd %xmm0,%xmm0
+#Following has to be commented and the above haddpd has to be uncommented if we can
+#use the SSE3 instructions
+    movapd %xmm0,%xmm3
+    unpckhpd %xmm3,%xmm3
+    addsd %xmm3,%xmm0
+#######################################################################    
+    addsd .L__one_mask_64(%rip),%xmm0
+    mulsd %xmm7,%xmm0
+    lea .L__defined_cuberoot(%rip),%rax
+    mulsd (%rax,%rdx,8),%xmm0
+    
+    mulsd %xmm4,%xmm0
+    cmp $1,%cx
+    jnz .L__final_result
+    mulsd .L__denormal_factor(%rip),%xmm0
+
+.align 32
+.L__final_result:
+    por %xmm6, %xmm0 
+    cvtsd2ss %xmm0,%xmm0
+    add   $stack_size, %rsp
+    ret
+     
+         
+.align 32
+.L__cbrtf_is_denormal:   
+    cmp $0,%r9
+    jz .L__cbrtf_is_zero
+    mulss .L__2_pow_23(%rip),%xmm1
+    movss  %xmm1, store_input(%rsp)
+    mov   $1,%cx
+    mov   store_input(%rsp),%r8
+    mov   %r8,%r9
+    and   %r10,%r8 # r8 = stores the exponent
+    and   %r11,%r9 # r9 = stores the mantissa
+    jmp .L__cbrtf_is_normal 
+
+.align 32
+.L__cbrtf_is_nan_infinite:
+    cmp $0,%r9
+    jz .L__cbrtf_is_infinite
+    mulss %xmm0,%xmm0 #this multiplication will raise an invalid exception
+    por  .L__qnan_mask_32(%rip),%xmm0
+
+.L__cbrtf_is_infinite:
+.L__cbrtf_is_one:    
+.L__cbrtf_is_zero:    
+    add   $stack_size, %rsp
+    ret
+
+.align 32 
+.L__mantissa_mask_32:      .long 0x007FFFFF
+                           .long 0          #this zero is necessary
+.align 16                           
+.L__qnan_mask_32:          .long 0x00400000
+                           .long 0
+.L__exp_mask_32:           .long 0x7F800000
+                           .long 0
+.L__zero:                  .long 0x00000000
+                           .long 0
+.align 16
+.L__mantissa_mask_64:      .quad 0x000FFFFFFFFFFFFF
+.L__2_pow_23:              .long 0x4B000000
+
+
+.align 16
+.L__sign_mask_64:          .quad 0x8000000000000000 
+                           .quad 0
+.L__one_mask_64:           .quad 0x3FF0000000000000 
+                           .quad 0
+
+.align 16
+.L__denormal_factor:       .quad 0x3F7428A2F98D728B 
+                           .quad 0
+.align 16
+.L__coefficients:
+    .quad 0xbFBC71C71C71C71C
+    .quad 0x3fd5555555555555
+.align 16
+.L__defined_cuberoot:   .quad 0x3FE428A2F98D728B
+                        .quad 0x3FE965FEA53D6E3D
+                        .quad 0x3FF0000000000000
+                        .quad 0x3FF428A2F98D728B
+                        .quad 0x3FF965FEA53D6E3D
+                         
+.align 32 
+.L__DoubleReciprocalTable_256: .quad 0X3ff0000000000000
+            .quad 0X3fefe00000000000
+            .quad 0X3fefc00000000000
+            .quad 0X3fefa00000000000
+            .quad 0X3fef800000000000
+            .quad 0X3fef600000000000
+            .quad 0X3fef400000000000
+            .quad 0X3fef200000000000
+            .quad 0X3fef000000000000
+            .quad 0X3feee00000000000
+            .quad 0X3feec00000000000
+            .quad 0X3feea00000000000
+            .quad 0X3fee900000000000
+            .quad 0X3fee700000000000
+            .quad 0X3fee500000000000
+            .quad 0X3fee300000000000
+            .quad 0X3fee100000000000
+            .quad 0X3fee000000000000
+            .quad 0X3fede00000000000
+            .quad 0X3fedc00000000000
+            .quad 0X3feda00000000000
+            .quad 0X3fed900000000000
+            .quad 0X3fed700000000000
+            .quad 0X3fed500000000000
+            .quad 0X3fed400000000000
+            .quad 0X3fed200000000000
+            .quad 0X3fed000000000000
+            .quad 0X3fecf00000000000
+            .quad 0X3fecd00000000000
+            .quad 0X3fecb00000000000
+            .quad 0X3feca00000000000
+            .quad 0X3fec800000000000
+            .quad 0X3fec700000000000
+            .quad 0X3fec500000000000
+            .quad 0X3fec300000000000
+            .quad 0X3fec200000000000
+            .quad 0X3fec000000000000
+            .quad 0X3febf00000000000
+            .quad 0X3febd00000000000
+            .quad 0X3febc00000000000
+            .quad 0X3feba00000000000
+            .quad 0X3feb900000000000
+            .quad 0X3feb700000000000
+            .quad 0X3feb600000000000
+            .quad 0X3feb400000000000
+            .quad 0X3feb300000000000
+            .quad 0X3feb200000000000
+            .quad 0X3feb000000000000
+            .quad 0X3feaf00000000000
+            .quad 0X3fead00000000000
+            .quad 0X3feac00000000000
+            .quad 0X3feaa00000000000
+            .quad 0X3fea900000000000
+            .quad 0X3fea800000000000
+            .quad 0X3fea600000000000
+            .quad 0X3fea500000000000
+            .quad 0X3fea400000000000
+            .quad 0X3fea200000000000
+            .quad 0X3fea100000000000
+            .quad 0X3fea000000000000
+            .quad 0X3fe9e00000000000
+            .quad 0X3fe9d00000000000
+            .quad 0X3fe9c00000000000
+            .quad 0X3fe9a00000000000
+            .quad 0X3fe9900000000000
+            .quad 0X3fe9800000000000
+            .quad 0X3fe9700000000000
+            .quad 0X3fe9500000000000
+            .quad 0X3fe9400000000000
+            .quad 0X3fe9300000000000
+            .quad 0X3fe9200000000000
+            .quad 0X3fe9000000000000
+            .quad 0X3fe8f00000000000
+            .quad 0X3fe8e00000000000
+            .quad 0X3fe8d00000000000
+            .quad 0X3fe8b00000000000
+            .quad 0X3fe8a00000000000
+            .quad 0X3fe8900000000000
+            .quad 0X3fe8800000000000
+            .quad 0X3fe8700000000000
+            .quad 0X3fe8600000000000
+            .quad 0X3fe8400000000000
+            .quad 0X3fe8300000000000
+            .quad 0X3fe8200000000000
+            .quad 0X3fe8100000000000
+            .quad 0X3fe8000000000000
+            .quad 0X3fe7f00000000000
+            .quad 0X3fe7e00000000000
+            .quad 0X3fe7d00000000000
+            .quad 0X3fe7b00000000000
+            .quad 0X3fe7a00000000000
+            .quad 0X3fe7900000000000
+            .quad 0X3fe7800000000000
+            .quad 0X3fe7700000000000
+            .quad 0X3fe7600000000000
+            .quad 0X3fe7500000000000
+            .quad 0X3fe7400000000000
+            .quad 0X3fe7300000000000
+            .quad 0X3fe7200000000000
+            .quad 0X3fe7100000000000
+            .quad 0X3fe7000000000000
+            .quad 0X3fe6f00000000000
+            .quad 0X3fe6e00000000000
+            .quad 0X3fe6d00000000000
+            .quad 0X3fe6c00000000000
+            .quad 0X3fe6b00000000000
+            .quad 0X3fe6a00000000000
+            .quad 0X3fe6900000000000
+            .quad 0X3fe6800000000000
+            .quad 0X3fe6700000000000
+            .quad 0X3fe6600000000000
+            .quad 0X3fe6500000000000
+            .quad 0X3fe6400000000000
+            .quad 0X3fe6300000000000
+            .quad 0X3fe6200000000000
+            .quad 0X3fe6100000000000
+            .quad 0X3fe6000000000000
+            .quad 0X3fe5f00000000000
+            .quad 0X3fe5e00000000000
+            .quad 0X3fe5d00000000000
+            .quad 0X3fe5c00000000000
+            .quad 0X3fe5b00000000000
+            .quad 0X3fe5a00000000000
+            .quad 0X3fe5900000000000
+            .quad 0X3fe5800000000000
+            .quad 0X3fe5800000000000
+            .quad 0X3fe5700000000000
+            .quad 0X3fe5600000000000
+            .quad 0X3fe5500000000000
+            .quad 0X3fe5400000000000
+            .quad 0X3fe5300000000000
+            .quad 0X3fe5200000000000
+            .quad 0X3fe5100000000000
+            .quad 0X3fe5000000000000
+            .quad 0X3fe5000000000000
+            .quad 0X3fe4f00000000000
+            .quad 0X3fe4e00000000000
+            .quad 0X3fe4d00000000000
+            .quad 0X3fe4c00000000000
+            .quad 0X3fe4b00000000000
+            .quad 0X3fe4a00000000000
+            .quad 0X3fe4a00000000000
+            .quad 0X3fe4900000000000
+            .quad 0X3fe4800000000000
+            .quad 0X3fe4700000000000
+            .quad 0X3fe4600000000000
+            .quad 0X3fe4600000000000
+            .quad 0X3fe4500000000000
+            .quad 0X3fe4400000000000
+            .quad 0X3fe4300000000000
+            .quad 0X3fe4200000000000
+            .quad 0X3fe4200000000000
+            .quad 0X3fe4100000000000
+            .quad 0X3fe4000000000000
+            .quad 0X3fe3f00000000000
+            .quad 0X3fe3e00000000000
+            .quad 0X3fe3e00000000000
+            .quad 0X3fe3d00000000000
+            .quad 0X3fe3c00000000000
+            .quad 0X3fe3b00000000000
+            .quad 0X3fe3b00000000000
+            .quad 0X3fe3a00000000000
+            .quad 0X3fe3900000000000
+            .quad 0X3fe3800000000000
+            .quad 0X3fe3800000000000
+            .quad 0X3fe3700000000000
+            .quad 0X3fe3600000000000
+            .quad 0X3fe3500000000000
+            .quad 0X3fe3500000000000
+            .quad 0X3fe3400000000000
+            .quad 0X3fe3300000000000
+            .quad 0X3fe3200000000000
+            .quad 0X3fe3200000000000
+            .quad 0X3fe3100000000000
+            .quad 0X3fe3000000000000
+            .quad 0X3fe3000000000000
+            .quad 0X3fe2f00000000000
+            .quad 0X3fe2e00000000000
+            .quad 0X3fe2e00000000000
+            .quad 0X3fe2d00000000000
+            .quad 0X3fe2c00000000000
+            .quad 0X3fe2b00000000000
+            .quad 0X3fe2b00000000000
+            .quad 0X3fe2a00000000000
+            .quad 0X3fe2900000000000
+            .quad 0X3fe2900000000000
+            .quad 0X3fe2800000000000
+            .quad 0X3fe2700000000000
+            .quad 0X3fe2700000000000
+            .quad 0X3fe2600000000000
+            .quad 0X3fe2500000000000
+            .quad 0X3fe2500000000000
+            .quad 0X3fe2400000000000
+            .quad 0X3fe2300000000000
+            .quad 0X3fe2300000000000
+            .quad 0X3fe2200000000000
+            .quad 0X3fe2100000000000
+            .quad 0X3fe2100000000000
+            .quad 0X3fe2000000000000
+            .quad 0X3fe2000000000000
+            .quad 0X3fe1f00000000000
+            .quad 0X3fe1e00000000000
+            .quad 0X3fe1e00000000000
+            .quad 0X3fe1d00000000000
+            .quad 0X3fe1c00000000000
+            .quad 0X3fe1c00000000000
+            .quad 0X3fe1b00000000000
+            .quad 0X3fe1b00000000000
+            .quad 0X3fe1a00000000000
+            .quad 0X3fe1900000000000
+            .quad 0X3fe1900000000000
+            .quad 0X3fe1800000000000
+            .quad 0X3fe1800000000000
+            .quad 0X3fe1700000000000
+            .quad 0X3fe1600000000000
+            .quad 0X3fe1600000000000
+            .quad 0X3fe1500000000000
+            .quad 0X3fe1500000000000
+            .quad 0X3fe1400000000000
+            .quad 0X3fe1300000000000
+            .quad 0X3fe1300000000000
+            .quad 0X3fe1200000000000
+            .quad 0X3fe1200000000000
+            .quad 0X3fe1100000000000
+            .quad 0X3fe1100000000000
+            .quad 0X3fe1000000000000
+            .quad 0X3fe0f00000000000
+            .quad 0X3fe0f00000000000
+            .quad 0X3fe0e00000000000
+            .quad 0X3fe0e00000000000
+            .quad 0X3fe0d00000000000
+            .quad 0X3fe0d00000000000
+            .quad 0X3fe0c00000000000
+            .quad 0X3fe0c00000000000
+            .quad 0X3fe0b00000000000
+            .quad 0X3fe0a00000000000
+            .quad 0X3fe0a00000000000
+            .quad 0X3fe0900000000000
+            .quad 0X3fe0900000000000
+            .quad 0X3fe0800000000000
+            .quad 0X3fe0800000000000
+            .quad 0X3fe0700000000000
+            .quad 0X3fe0700000000000
+            .quad 0X3fe0600000000000
+            .quad 0X3fe0600000000000
+            .quad 0X3fe0500000000000
+            .quad 0X3fe0500000000000
+            .quad 0X3fe0400000000000
+            .quad 0X3fe0400000000000
+            .quad 0X3fe0300000000000
+            .quad 0X3fe0300000000000
+            .quad 0X3fe0200000000000
+            .quad 0X3fe0200000000000
+            .quad 0X3fe0100000000000
+            .quad 0X3fe0100000000000
+            .quad 0X3fe0000000000000
+    
+.align 32
+.L__CubeRootTable_256:   .quad 0X3ff0000000000000 
+                         .quad 0X3ff00558e6547c36 
+                         .quad 0X3ff00ab8f9d2f374 
+                         .quad 0X3ff010204b673fc7 
+                         .quad 0X3ff0158eec36749b 
+                         .quad 0X3ff01b04ed9fdb53 
+                         .quad 0X3ff02082613df53c 
+                         .quad 0X3ff0260758e78308 
+                         .quad 0X3ff02b93e6b091f0 
+                         .quad 0X3ff031281ceb8ea2 
+                         .quad 0X3ff036c40e2a5e2a 
+                         .quad 0X3ff03c67cd3f7cea 
+                         .quad 0X3ff03f3c9fee224c 
+                         .quad 0X3ff044ec379f7f79 
+                         .quad 0X3ff04aa3cd578d67 
+                         .quad 0X3ff0506374d40a3d 
+                         .quad 0X3ff0562b4218a6e3 
+                         .quad 0X3ff059123d3a9848 
+                         .quad 0X3ff05ee6694e7166 
+                         .quad 0X3ff064c2ee6e07c6 
+                         .quad 0X3ff06aa7e19c01c5 
+                         .quad 0X3ff06d9d8b1decca 
+                         .quad 0X3ff0738f4b6cc8e2 
+                         .quad 0X3ff07989af9f9f59 
+                         .quad 0X3ff07c8a2611201c 
+                         .quad 0X3ff08291a9958f03 
+                         .quad 0X3ff088a208c3fe28 
+                         .quad 0X3ff08bad91dd7d8b 
+                         .quad 0X3ff091cb6588465e 
+                         .quad 0X3ff097f24eab04a1 
+                         .quad 0X3ff09b0932aee3f2 
+                         .quad 0X3ff0a13de8970de4 
+                         .quad 0X3ff0a45bc08a5ac7 
+                         .quad 0X3ff0aa9e79bfa986 
+                         .quad 0X3ff0b0eaa961ca5b 
+                         .quad 0X3ff0b4145573271c 
+                         .quad 0X3ff0ba6ee5f9aad4 
+                         .quad 0X3ff0bd9fd0dbe02d 
+                         .quad 0X3ff0c408fc1cfd4b 
+                         .quad 0X3ff0c741430e2059 
+                         .quad 0X3ff0cdb9442ea813 
+                         .quad 0X3ff0d0f905168e6c 
+                         .quad 0X3ff0d7801893d261 
+                         .quad 0X3ff0dac772091bde 
+                         .quad 0X3ff0e15dd5c330ab 
+                         .quad 0X3ff0e4ace71080a4 
+                         .quad 0X3ff0e7fe920f3037 
+                         .quad 0X3ff0eea9c37e497e 
+                         .quad 0X3ff0f203512f4314 
+                         .quad 0X3ff0f8be68db7f32 
+                         .quad 0X3ff0fc1ffa42d902 
+                         .quad 0X3ff102eb3af9ed89 
+                         .quad 0X3ff10654f1e29cfb 
+                         .quad 0X3ff109c1679c189f 
+                         .quad 0X3ff110a29f080b3d 
+                         .quad 0X3ff114176891738a 
+                         .quad 0X3ff1178f0099b429 
+                         .quad 0X3ff11e86ac2cd7ab 
+                         .quad 0X3ff12206c7cf4046 
+                         .quad 0X3ff12589c21fb842 
+                         .quad 0X3ff12c986355d0d2 
+                         .quad 0X3ff13024129645cf 
+                         .quad 0X3ff133b2b13aa0eb 
+                         .quad 0X3ff13ad8cdc48ba3 
+                         .quad 0X3ff13e70544b1d4f 
+                         .quad 0X3ff1420adb77c99a 
+                         .quad 0X3ff145a867b1bfea 
+                         .quad 0X3ff14ceca1189d6d 
+                         .quad 0X3ff15093574284e9 
+                         .quad 0X3ff1543d2473ea9b 
+                         .quad 0X3ff157ea0d433a46 
+                         .quad 0X3ff15f4d44462724 
+                         .quad 0X3ff163039bd7cde6 
+                         .quad 0X3ff166bd21c3a8e2 
+                         .quad 0X3ff16a79dad1fb59 
+                         .quad 0X3ff171fcf9aaac3d 
+                         .quad 0X3ff175c3693980c3 
+                         .quad 0X3ff1798d1f73f3ef 
+                         .quad 0X3ff17d5a2156e97f 
+                         .quad 0X3ff1812a73ea2593 
+                         .quad 0X3ff184fe1c406b8f 
+                         .quad 0X3ff18caf82b8dba4 
+                         .quad 0X3ff1908d4b38a510 
+                         .quad 0X3ff1946e7e36f7e5 
+                         .quad 0X3ff1985320ff72a2 
+                         .quad 0X3ff19c3b38e975a8 
+                         .quad 0X3ff1a026cb58453d 
+                         .quad 0X3ff1a415ddbb2c10 
+                         .quad 0X3ff1a808758d9e32 
+                         .quad 0X3ff1aff84bac98ea 
+                         .quad 0X3ff1b3f5952e1a50 
+                         .quad 0X3ff1b7f67a896220 
+                         .quad 0X3ff1bbfb0178d186 
+                         .quad 0X3ff1c0032fc3cf91 
+                         .quad 0X3ff1c40f0b3eefc4 
+                         .quad 0X3ff1c81e99cc193f 
+                         .quad 0X3ff1cc31e15aae72 
+                         .quad 0X3ff1d048e7e7b565 
+                         .quad 0X3ff1d463b37e0090 
+                         .quad 0X3ff1d8824a365852 
+                         .quad 0X3ff1dca4b237a4f7 
+                         .quad 0X3ff1e0caf1b71965 
+                         .quad 0X3ff1e4f50ef85e61 
+                         .quad 0X3ff1e923104dbe76 
+                         .quad 0X3ff1ed54fc185286 
+                         .quad 0X3ff1f18ad8c82efc 
+                         .quad 0X3ff1f5c4acdc91aa 
+                         .quad 0X3ff1fa027ee4105b 
+                         .quad 0X3ff1fe44557cc808 
+                         .quad 0X3ff2028a37548ccf 
+                         .quad 0X3ff206d42b291a95 
+                         .quad 0X3ff20b2237c8466a 
+                         .quad 0X3ff20f74641030a6 
+                         .quad 0X3ff213cab6ef77c7 
+                         .quad 0X3ff2182537656c13 
+                         .quad 0X3ff21c83ec824406 
+                         .quad 0X3ff220e6dd675180 
+                         .quad 0X3ff2254e114737d2 
+                         .quad 0X3ff229b98f66228c 
+                         .quad 0X3ff22e295f19fd31 
+                         .quad 0X3ff2329d87caabb6 
+                         .quad 0X3ff2371610f243f2 
+                         .quad 0X3ff23b93021d47da 
+                         .quad 0X3ff2401462eae0b8 
+                         .quad 0X3ff2449a3b0d1b3f 
+                         .quad 0X3ff2449a3b0d1b3f 
+                         .quad 0X3ff2492492492492 
+                         .quad 0X3ff24db370778844 
+                         .quad 0X3ff25246dd846f45 
+                         .quad 0X3ff256dee16fdfd4 
+                         .quad 0X3ff25b7b844dfe71 
+                         .quad 0X3ff2601cce474fd2 
+                         .quad 0X3ff264c2c798fbe5 
+                         .quad 0X3ff2696d789511e2 
+                         .quad 0X3ff2696d789511e2 
+                         .quad 0X3ff26e1ce9a2cd73 
+                         .quad 0X3ff272d1233edcf3 
+                         .quad 0X3ff2778a2dfba8d0 
+                         .quad 0X3ff27c4812819c13 
+                         .quad 0X3ff2810ad98f6e10 
+                         .quad 0X3ff285d28bfa6d45 
+                         .quad 0X3ff285d28bfa6d45 
+                         .quad 0X3ff28a9f32aecb79 
+                         .quad 0X3ff28f70d6afeb08 
+                         .quad 0X3ff294478118ad83 
+                         .quad 0X3ff299233b1bc38a 
+                         .quad 0X3ff299233b1bc38a 
+                         .quad 0X3ff29e040e03fdfb 
+                         .quad 0X3ff2a2ea0334a07b 
+                         .quad 0X3ff2a7d52429b556 
+                         .quad 0X3ff2acc57a7862c2 
+                         .quad 0X3ff2acc57a7862c2 
+                         .quad 0X3ff2b1bb0fcf4190 
+                         .quad 0X3ff2b6b5edf6b54a 
+                         .quad 0X3ff2bbb61ed145cf 
+                         .quad 0X3ff2c0bbac5bfa6e 
+                         .quad 0X3ff2c0bbac5bfa6e 
+                         .quad 0X3ff2c5c6a0aeb681 
+                         .quad 0X3ff2cad705fc97a6 
+                         .quad 0X3ff2cfece6945583 
+                         .quad 0X3ff2cfece6945583 
+                         .quad 0X3ff2d5084ce0a331 
+                         .quad 0X3ff2da294368924f 
+                         .quad 0X3ff2df4fd4cff7c3 
+                         .quad 0X3ff2df4fd4cff7c3 
+                         .quad 0X3ff2e47c0bd7d237 
+                         .quad 0X3ff2e9adf35eb25a 
+                         .quad 0X3ff2eee5966124e8 
+                         .quad 0X3ff2eee5966124e8 
+                         .quad 0X3ff2f422fffa1e92 
+                         .quad 0X3ff2f9663b6369b6 
+                         .quad 0X3ff2feaf53f61612 
+                         .quad 0X3ff2feaf53f61612 
+                         .quad 0X3ff303fe552aea57 
+                         .quad 0X3ff309534a9ad7ce 
+                         .quad 0X3ff309534a9ad7ce 
+                         .quad 0X3ff30eae3fff6ff3 
+                         .quad 0X3ff3140f41335c2f 
+                         .quad 0X3ff3140f41335c2f 
+                         .quad 0X3ff319765a32d7ae 
+                         .quad 0X3ff31ee3971c2b5b 
+                         .quad 0X3ff3245704302c13 
+                         .quad 0X3ff3245704302c13 
+                         .quad 0X3ff329d0add2bb20 
+                         .quad 0X3ff32f50a08b48f9 
+                         .quad 0X3ff32f50a08b48f9 
+                         .quad 0X3ff334d6e9055a5f 
+                         .quad 0X3ff33a6394110fe6 
+                         .quad 0X3ff33a6394110fe6 
+                         .quad 0X3ff33ff6aea3afed 
+                         .quad 0X3ff3459045d8331b 
+                         .quad 0X3ff3459045d8331b 
+                         .quad 0X3ff34b3066efd36b 
+                         .quad 0X3ff350d71f529dd8 
+                         .quad 0X3ff350d71f529dd8 
+                         .quad 0X3ff356847c9006b4 
+                         .quad 0X3ff35c388c5f80bf 
+                         .quad 0X3ff35c388c5f80bf 
+                         .quad 0X3ff361f35ca116ff 
+                         .quad 0X3ff361f35ca116ff 
+                         .quad 0X3ff367b4fb5e0985 
+                         .quad 0X3ff36d7d76c96d0a 
+                         .quad 0X3ff36d7d76c96d0a 
+                         .quad 0X3ff3734cdd40cd95 
+                         .quad 0X3ff379233d4cd42a 
+                         .quad 0X3ff379233d4cd42a 
+                         .quad 0X3ff37f00a5a1ef96 
+                         .quad 0X3ff37f00a5a1ef96 
+                         .quad 0X3ff384e52521006c 
+                         .quad 0X3ff38ad0cad80848 
+                         .quad 0X3ff38ad0cad80848 
+                         .quad 0X3ff390c3a602dc60 
+                         .quad 0X3ff390c3a602dc60 
+                         .quad 0X3ff396bdc60bdb88 
+                         .quad 0X3ff39cbf3a8ca7a9 
+                         .quad 0X3ff39cbf3a8ca7a9 
+                         .quad 0X3ff3a2c8134ee2d1 
+                         .quad 0X3ff3a2c8134ee2d1 
+                         .quad 0X3ff3a8d8604cefe3 
+                         .quad 0X3ff3aef031b2b706 
+                         .quad 0X3ff3aef031b2b706 
+                         .quad 0X3ff3b50f97de6de5 
+                         .quad 0X3ff3b50f97de6de5 
+                         .quad 0X3ff3bb36a36163d8 
+                         .quad 0X3ff3bb36a36163d8 
+                         .quad 0X3ff3c1656500d20a 
+                         .quad 0X3ff3c79bedb6afb8 
+                         .quad 0X3ff3c79bedb6afb8 
+                         .quad 0X3ff3cdda4eb28aa2 
+                         .quad 0X3ff3cdda4eb28aa2 
+                         .quad 0X3ff3d420995a63c0 
+                         .quad 0X3ff3d420995a63c0 
+                         .quad 0X3ff3da6edf4b9061 
+                         .quad 0X3ff3da6edf4b9061 
+                         .quad 0X3ff3e0c5325b9fc2 
+                         .quad 0X3ff3e723a499453f 
+                         .quad 0X3ff3e723a499453f 
+                         .quad 0X3ff3ed8a484d473a 
+                         .quad 0X3ff3ed8a484d473a 
+                         .quad 0X3ff3f3f92ffb72d8 
+                         .quad 0X3ff3f3f92ffb72d8 
+                         .quad 0X3ff3fa706e6394a4 
+                         .quad 0X3ff3fa706e6394a4 
+                         .quad 0X3ff400f01682764a 
+                         .quad 0X3ff400f01682764a 
+                         .quad 0X3ff407783b92e17a 
+                         .quad 0X3ff407783b92e17a 
+                         .quad 0X3ff40e08f10ea81a 
+                         .quad 0X3ff40e08f10ea81a 
+                         .quad 0X3ff414a24aafb1e6 
+                         .quad 0X3ff414a24aafb1e6 
+                         .quad 0X3ff41b445c710fa7 
+                         .quad 0X3ff41b445c710fa7 
+                         .quad 0X3ff421ef3a901411 
+                         .quad 0X3ff421ef3a901411 
+                         .quad 0X3ff428a2f98d728b 
+
+
+
+
+
+
diff --git a/src/gas/copysign.S b/src/gas/copysign.S
new file mode 100644
index 0000000..d5b96cf
--- /dev/null
+++ b/src/gas/copysign.S
@@ -0,0 +1,63 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#copysign.S
+#
+# An implementation of the copysign libm function.
+#
+# The copysign functions produce a value with the magnitude of x and the sign of y.
+# They produce a NaN (with the sign of y) if x is a NaN. On implementations that
+# represent a signed zero but do not treat negative zero consistently in arithmetic
+# operations, the copysign functions regard the sign of zero as positive.
+#
+#
+# Prototype:
+#
+#     double copysign(float x, float y)
+#
+#
+#
+#   Algorithm:
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(copysign)
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+
+	PSLLQ $1,%xmm0
+	PSRLQ $1,%xmm0
+	PSRLQ $63,%xmm1
+	PSLLQ $63,%xmm1
+	POR   %xmm1,%xmm0
+	
+    ret
diff --git a/src/gas/copysignf.S b/src/gas/copysignf.S
new file mode 100644
index 0000000..90e63d6
--- /dev/null
+++ b/src/gas/copysignf.S
@@ -0,0 +1,70 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#copysignf.S
+#
+# An implementation of the copysignf libm function.
+#
+# The copysign functions produce a value with the magnitude of x and the sign of y.
+# They produce a NaN (with the sign of y) if x is a NaN. On implementations that
+# represent a signed zero but do not treat negative zero consistently in arithmetic
+# operations, the copysign functions regard the sign of zero as positive.
+#
+# Prototype:
+#
+#     float copysignf(float x, float y)#
+#
+
+#
+#   Algorithm:
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(copysignf)
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+	#PANDN .L__fabsf_and_mask, %xmm1
+	#POR %xmm1,%xmm0 
+
+	PSLLD $1,%xmm0
+	PSRLD $1,%xmm0
+	PSRLD $31,%xmm1
+	PSLLD $31,%xmm1
+	POR   %xmm1,%xmm0
+	
+    ret
+
+#.align 16
+#.L__sign_mask:               .long 0x7FFFFFFF
+                             .long 0x0
+                             .quad 0x0
+
diff --git a/src/gas/cos.S b/src/gas/cos.S
new file mode 100644
index 0000000..dc227e0
--- /dev/null
+++ b/src/gas/cos.S
@@ -0,0 +1,485 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#
+# An implementation of the cos function.
+#
+# Prototype:
+#
+#     double cos(double x);
+#
+#   Computes cos(x).
+#   It will provide proper C99 return values,
+#   but may not raise floating point status bits properly.
+#   Based on the NAG C implementation.
+#
+#
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.data
+.align 32
+.L__real_7fffffffffffffff: .quad 0x07fffffffffffffff  #Sign bit zero
+                        .quad 0                       # for alignment
+.L__real_3ff0000000000000: .quad 0x03ff0000000000000  # 1.0
+                        .quad 0                    
+.L__real_3fe0000000000000: .quad 0x03fe0000000000000  # 0.5
+                        .quad 0
+.L__real_3fc5555555555555: .quad 0x03fc5555555555555  # 0.166666666666
+                        .quad 0
+.L__real_3fe45f306dc9c883: .quad 0x03fe45f306dc9c883  # twobypi
+                        .quad 0
+.L__real_3ff921fb54400000: .quad 0x03ff921fb54400000  # piby2_1
+                        .quad 0
+.L__real_3dd0b4611a626331: .quad 0x03dd0b4611a626331  # piby2_1tail
+                        .quad 0
+.L__real_3dd0b4611a600000: .quad 0x03dd0b4611a600000  # piby2_2
+                        .quad 0
+.L__real_3ba3198a2e037073: .quad 0x03ba3198a2e037073  # piby2_2tail
+                        .quad 0                   
+.L__real_fffffffff8000000: .quad 0x0fffffffff8000000  # mask for stripping head and tail
+                        .quad 0                    
+.L__real_411E848000000000: .quad 0x415312d000000000   # 5e6 0x0411E848000000000  # 5e5
+                        .quad 0
+.L__real_bfe0000000000000: .quad 0x0bfe0000000000000  # - 0.5
+                        .quad 0
+                        
+.align 32
+.Lcosarray:
+    .quad    0x3fa5555555555555                       # 0.0416667     c1
+    .quad    0
+    .quad    0xbf56c16c16c16967                       # -0.00138889   c2
+    .quad    0
+    .quad    0x3EFA01A019F4EC91                       # 2.48016e-005  c3
+    .quad    0
+    .quad    0xbE927E4FA17F667B                       # -2.75573e-007 c4
+    .quad    0
+    .quad    0x3E21EEB690382EEC                       # 2.08761e-009  c5
+    .quad    0
+    .quad    0xbDA907DB47258AA7                       # -1.13826e-011 c6
+    .quad    0
+
+.align 32
+.Lsinarray:
+    .quad    0xbfc5555555555555                       # -0.166667     s1
+    .quad    0
+    .quad    0x3f81111111110bb3                       # 0.00833333    s2
+    .quad    0
+    .quad    0xbf2a01a019e83e5c                       # -0.000198413  s3
+    .quad    0
+    .quad    0x3ec71de3796cde01                       # 2.75573e-006  s4
+    .quad    0
+    .quad    0xbe5ae600b42fdfa7                       # -2.50511e-008 s5
+    .quad    0
+    .quad    0x3de5e0b2f9a43bb8                       # 1.59181e-010  s6
+    .quad    0
+
+.text
+.align 32
+.p2align 5,,31
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(cos)
+#define fname_special _cos_special@PLT
+    
+# define local variable storage offsets
+.equ    p_temp,    0x30                               # temporary for get/put bits operation
+.equ    p_temp1,   0x40                               # temporary for get/put bits operation
+.equ    r,         0x50                               # pointer to r for amd_remainder_piby2
+.equ    rr,        0x60                               # pointer to rr for amd_remainder_piby2
+.equ    region,    0x70                               # pointer to region for amd_remainder_piby2
+.equ   stack_size, 0x98
+
+.globl fname
+.type  fname,@function
+
+fname:
+   sub      $stack_size, %rsp
+    xorpd   %xmm2, %xmm2                              # zeroed out for later use
+
+# GET_BITS_DP64(x, ux);
+# get the input value to an integer register.
+    movsd   %xmm0,p_temp(%rsp)
+    mov     p_temp(%rsp), %rdx                        # rdx is ux
+
+##  if NaN or inf
+    mov     $0x07ff0000000000000, %rax
+    mov     %rax, %r10
+    and     %rdx, %r10
+    cmp     %rax, %r10
+    jz      .Lcos_naninf
+
+#  ax = (ux & ~SIGNBIT_DP64);
+    mov     $0x07fffffffffffffff, %r10
+    and     %rdx, %r10                                # r10 is ax
+    mov     $1, %r8d                                  # for determining region later on
+
+
+##  if (ax <= 0x3fe921fb54442d18) /* abs(x) <= pi/4 */
+    mov     $0x03fe921fb54442d18, %rax
+    cmp     %rax, %r10
+    jg      .Lcos_reduce
+
+##      if (ax < 0x3f20000000000000) /* abs(x) < 2.0^(-13) */
+    mov     $0x03f20000000000000, %rax
+    cmp     %rax, %r10
+    jge     .Lcos_small
+
+##          if (ax < 0x3e40000000000000) /* abs(x) < 2.0^(-27) */
+    mov     $0x03e40000000000000, %rax
+    cmp     %rax, %r10
+    jge     .Lcos_smaller
+
+#                  cos = 1.0;
+    movsd   .L__real_3ff0000000000000(%rip), %xmm0    # return a 1
+    jmp     .Lcos_cleanup     
+
+##          else
+.align 16
+.Lcos_smaller:
+#              cos = 1.0 - x*x*0.5;
+    movsd   %xmm0, %xmm2
+    mulsd   %xmm2, %xmm2                # x^2
+    movsd   .L__real_3ff0000000000000(%rip), %xmm0    # 1.0
+    mulsd   .L__real_3fe0000000000000(%rip), %xmm2    # 0.5 * x^2
+    subsd   %xmm2, %xmm0
+    jmp     .Lcos_cleanup  
+           
+##      else
+
+.align 16
+.Lcos_small:
+#          cos = cos_piby4(x, 0.0);
+    movsd   %xmm0, %xmm2
+    mulsd   %xmm0, %xmm2                              # x2
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# region 0 or 2     - do a cos calculation
+#  zc = (c2 + x2 * (c3 + x2 * (c4 + x2 * (c5 + x2 * c6))));
+
+    movsd   .Lcosarray+0x10(%rip), %xmm1              # c2
+    movsd   %xmm2, %xmm4                              # move for x4
+    mulsd   %xmm2, %xmm4                              # x4
+    movsd   .Lcosarray+0x30(%rip), %xmm3              # c4
+    mulsd   %xmm2, %xmm1                              # c2x2
+    movsd   .Lcosarray+0x50(%rip), %xmm5              # c6
+    mulsd   %xmm2, %xmm3                              # c4x2
+    movsd   %xmm4, %xmm0                              # move for x8
+    mulsd   %xmm2, %xmm5                              # c6x2
+    mulsd   %xmm4, %xmm0                              # x8
+    addsd   .Lcosarray(%rip), %xmm1                   # c1 + c2x2
+    mulsd   %xmm4, %xmm1                              # c1x4 + c2x6
+    addsd   .Lcosarray+0x20(%rip), %xmm3              # c3 + c4x2
+    mulsd   .L__real_bfe0000000000000(%rip), %xmm2    # -0.5x2, destroy xmm2
+    addsd   .Lcosarray+0x40(%rip), %xmm5              # c5 + c6x2
+    mulsd   %xmm0, %xmm3                              # c3x8 + c4x10    
+    mulsd   %xmm0, %xmm4                              # x12    
+    mulsd   %xmm5, %xmm4                              # c5x12 + c6x14
+
+    movsd   .L__real_3ff0000000000000(%rip), %xmm0    # 1    
+    addsd   %xmm3, %xmm1                              # c1x4 + c2x6 + c3x8 + c4x10
+    movsd   %xmm2, %xmm3                              # preserve -0.5x2
+    addsd   %xmm0, %xmm2                              # t = 1 - 0.5x2
+    subsd   %xmm2, %xmm0                              # 1-t
+    addsd   %xmm3, %xmm0                              # (1-t) - r
+    addsd   %xmm4, %xmm1                              # c1x4 + c2x6 + c3x8 + c4x10 + c5x12 + c6x14
+    addsd   %xmm1, %xmm0                              # (1-t) - r + c1x4 + c2x6 + c3x8 + c4x10 + c5x12 + c6x14
+    addsd   %xmm2, %xmm0                              # 1 - 0.5x2 + above
+
+    jmp     .Lcos_cleanup
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcos_reduce:
+
+#  xneg = (ax != ux);
+    cmp     %r10, %rdx
+
+##  if (xneg) x = -x;
+    jz      .Lpositive
+    subsd   %xmm0, %xmm2
+    movsd   %xmm2, %xmm0
+
+.Lpositive:
+##  if (x < 5.0e5)
+    cmp     .L__real_411E848000000000(%rip), %r10
+    jae     .Lcos_reduce_precise
+
+# reduce  the argument to be in a range from -pi/4 to +pi/4
+# by subtracting multiples of pi/2
+    movsd   %xmm0, %xmm2
+    movsd   .L__real_3fe45f306dc9c883(%rip), %xmm3    # twobypi
+    movsd   %xmm0, %xmm4
+    movsd   .L__real_3fe0000000000000(%rip), %xmm5    # .5
+    mulsd   %xmm3, %xmm2
+
+#/* How many pi/2 is x a multiple of? */
+#      xexp  = ax >> EXPSHIFTBITS_DP64;
+    mov     %r10, %r9
+    shr     $52, %r9                                  # >>EXPSHIFTBITS_DP64
+
+#        npi2  = (int)(x * twobypi + 0.5);
+    addsd   %xmm5, %xmm2                              # npi2
+
+    movsd   .L__real_3ff921fb54400000(%rip), %xmm3    # piby2_1
+    cvttpd2dq    %xmm2, %xmm0                         # convert to integer
+    movsd   .L__real_3dd0b4611a626331(%rip), %xmm1    # piby2_1tail
+    cvtdq2pd    %xmm0, %xmm2                          # and back to float.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+#      rhead  = x - npi2 * piby2_1;
+    mulsd   %xmm2, %xmm3
+    subsd   %xmm3, %xmm4                              # rhead
+
+#      rtail  = npi2 * piby2_1tail;
+    mulsd   %xmm2, %xmm1
+    movd    %xmm0, %eax
+
+#      GET_BITS_DP64(rhead-rtail, uy);             
+    movsd   %xmm4, %xmm0
+    subsd   %xmm1, %xmm0
+
+    movsd   .L__real_3dd0b4611a600000(%rip), %xmm3    # piby2_2
+    movsd   %xmm0,p_temp(%rsp)
+    movsd   .L__real_3ba3198a2e037073(%rip), %xmm5    # piby2_2tail
+    mov     p_temp(%rsp), %rcx                        # rcx is rhead-rtail
+
+#    xmm0=r, xmm4=rhead, xmm1=rtail, xmm2=npi2, xmm3=temp for calc, xmm5= temp for calc
+#      expdiff = xexp - ((uy & EXPBITS_DP64) >> EXPSHIFTBITS_DP64);
+    shl     $1, %rcx                                  # strip any sign bit
+    shr     $53, %rcx                                 # >> EXPSHIFTBITS_DP64 +1
+    sub     %rcx, %r9                                 # expdiff
+
+##      if (expdiff > 15)
+    cmp     $15, %r9
+    jle     .Lexpdiffless15
+
+#          /* The remainder is pretty small compared with x, which
+#             implies that x is a near multiple of pi/2
+#             (x matches the multiple to at least 15 bits) */
+
+#          t  = rhead;
+    movsd   %xmm4, %xmm1
+
+#          rtail  = npi2 * piby2_2;
+    mulsd   %xmm2, %xmm3
+
+#          rhead  = t - rtail;
+    mulsd   %xmm2, %xmm5                              # npi2 * piby2_2tail
+    subsd   %xmm3, %xmm4                              # rhead
+
+#          rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+    subsd   %xmm4, %xmm1                              # t - rhead
+    subsd   %xmm3, %xmm1                              # -rtail
+    subsd   %xmm1, %xmm5                              # rtail
+
+#      r = rhead - rtail;
+    movsd   %xmm4, %xmm0
+
+#HARSHA
+#xmm1=rtail
+    movsd   %xmm5, %xmm1
+    subsd   %xmm5, %xmm0
+
+#    xmm0=r, xmm4=rhead, xmm1=rtail
+.Lexpdiffless15:
+#      region = npi2 & 3;
+
+    subsd   %xmm0, %xmm4                              # rhead-r
+    subsd   %xmm1, %xmm4                              # rr = (rhead-r) - rtail
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+## if the input was close to a pi/2 multiple
+# The original NAG code missed this trick.  If the input is very close to n*pi/2 after
+# reduction,
+# then the cos is ~ 1.0 , to within 53 bits, when r is < 2^-27.  We already
+# have x at this point, so we can skip the cos polynomials.
+
+    cmp     $0x03f2, %rcx                             # if r  small.
+    jge     .Lcos_piby4                               # use taylor series if not
+    cmp     $0x03de, %rcx                             # if r really small.
+    jle     .Lr_small                                 # then cos(r) = 1
+
+    movsd   %xmm0, %xmm2
+    mulsd   %xmm2, %xmm2                              # x^2
+
+##      if region is 1 or 3    do a sin calc.
+    and     %eax, %r8d
+    jz      .Lsinsmall
+
+# region 1 or 3
+# use simply polynomial
+#              *s = x - x*x*x*0.166666666666666666;
+    movsd   .L__real_3fc5555555555555(%rip), %xmm3    
+    mulsd   %xmm0, %xmm3                              # * x
+    mulsd   %xmm2, %xmm3                              # * x^2
+    subsd   %xmm3, %xmm0                              # xs
+    jmp     .Ladjust_region
+
+.align 16
+.Lsinsmall:
+# region 0 or 2
+#              cos = 1.0 - x*x*0.5;
+    movsd   .L__real_3ff0000000000000(%rip), %xmm0  # 1.0
+    mulsd   .L__real_3fe0000000000000(%rip), %xmm2  # 0.5 *x^2
+    subsd   %xmm2, %xmm0
+    jmp     .Ladjust_region
+
+.align 16
+.Lr_small:
+##      if region is 1 or 3    do a sin calc.
+    and     %eax, %r8d
+    jnz     .Ladjust_region
+
+    movsd   .L__real_3ff0000000000000(%rip), %xmm0    # cos(r) is a 1
+    jmp     .Ladjust_region
+
+.align 32
+.Lcos_reduce_precise:
+#      // Reduce x into range [-pi/4,pi/4]
+#      __amd_remainder_piby2(x, &r, &rr, &region);
+
+    lea     region(%rsp), %rdx
+    lea     rr(%rsp), %rsi
+    lea     r(%rsp), %rdi
+        
+    call    __amd_remainder_piby2@PLT
+
+    mov     $1, %r8d                                  # for determining region later on
+    movsd   r(%rsp), %xmm0                            # x
+    movsd   rr(%rsp), %xmm4                           # xx
+    mov     region(%rsp), %eax                        # region
+
+# xmm0 = x, xmm4 = xx, r8d = 1, eax= region
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 32
+# perform taylor series to calc sinx, cosx
+.Lcos_piby4:
+#  x2 = r * r;
+
+#xmm4 = a part of rr for the sin path, xmm4 is overwritten in the cos path
+#instead use xmm3 because that was freed up in the sin path, xmm3 is overwritten in sin path
+    movsd   %xmm0, %xmm3
+    movsd   %xmm0, %xmm2
+    mulsd   %xmm0, %xmm2                              # x2
+
+##      if region is 1 or 3    do a sin calc.
+    and     %eax, %r8d
+    jz      .Lcospiby4
+
+# region 1 or 3
+    movsd   .Lsinarray+0x50(%rip), %xmm3              # s6
+    mulsd   %xmm2, %xmm3                              # x2s6
+    movsd   .Lsinarray+0x20(%rip), %xmm5              # s3
+    movsd   %xmm4,p_temp(%rsp)                        # store xx
+    movsd   %xmm2, %xmm1                              # move for x4
+    mulsd   %xmm2, %xmm1                              # x4
+    movsd   %xmm0,p_temp1(%rsp)                       # store x
+    mulsd   %xmm2, %xmm5                              # x2s3
+    movsd   %xmm0, %xmm4                              # move for x3
+    addsd   .Lsinarray+0x40(%rip), %xmm3              # s5+x2s6
+    mulsd   %xmm2, %xmm1                              # x6
+    mulsd   %xmm2, %xmm3                              # x2(s5+x2s6)
+    mulsd   %xmm2, %xmm4                              # x3
+    addsd   .Lsinarray+0x10(%rip), %xmm5              # s2+x2s3
+    mulsd   %xmm2, %xmm5                              # x2(s2+x2s3)
+    addsd   .Lsinarray+0x30(%rip), %xmm3              # s4 + x2(s5+x2s6)
+    mulsd   .L__real_3fe0000000000000(%rip), %xmm2    # 0.5 *x2
+    movsd   p_temp(%rsp), %xmm0                       # load xx
+    mulsd   %xmm1, %xmm3                              # x6(s4 + x2(s5+x2s6))
+    addsd   .Lsinarray(%rip), %xmm5                   # s1+x2(s2+x2s3)
+    mulsd   %xmm0, %xmm2                              # 0.5 * x2 *xx
+    addsd   %xmm5, %xmm3                              # zs
+    mulsd   %xmm3, %xmm4                              # *x3
+    subsd   %xmm2, %xmm4                              # x3*zs - 0.5 * x2 *xx
+    addsd   %xmm4, %xmm0                              # +xx
+    addsd   p_temp1(%rsp), %xmm0                      # +x
+    
+    jmp     .Ladjust_region
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcospiby4:
+    
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# region 0 or 2     - do a cos calculation
+#  zc = (c2 + x2 * (c3 + x2 * (c4 + x2 * (c5 + x2 * c6))));
+    mulsd   %xmm0, %xmm4                              # x*xx
+    movsd   .L__real_3fe0000000000000(%rip), %xmm5
+    movsd   .Lcosarray+0x50(%rip), %xmm1              # c6
+    movsd   .Lcosarray+0x20(%rip), %xmm0              # c3
+    mulsd   %xmm2, %xmm5                              # r = 0.5 *x2
+    movsd   %xmm2, %xmm3                              # copy of x2
+    movsd   %xmm4,p_temp(%rsp)                        # store x*xx
+    mulsd   %xmm2, %xmm1                              # c6*x2
+    mulsd   %xmm2, %xmm0                              # c3*x2
+    subsd   .L__real_3ff0000000000000(%rip), %xmm5    # -t=r-1.0    ;trash r
+    mulsd   %xmm2, %xmm3                              # x4
+    addsd   .Lcosarray+0x40(%rip), %xmm1              # c5+x2c6
+    addsd   .Lcosarray+0x10(%rip), %xmm0              # c2+x2C3
+    addsd   .L__real_3ff0000000000000(%rip), %xmm5    # 1 + (-t)    ;trash t
+    mulsd   %xmm2, %xmm3                              # x6
+    mulsd   %xmm2, %xmm1                              # x2(c5+x2c6)
+    mulsd   %xmm2, %xmm0                              # x2(c2+x2C3)
+    movsd   %xmm2, %xmm4                              # copy of x2
+    mulsd   .L__real_3fe0000000000000(%rip), %xmm4    # r recalculate
+    addsd   .Lcosarray+0x30(%rip), %xmm1              # c4 + x2(c5+x2c6)
+    addsd   .Lcosarray(%rip), %xmm0                   # c1+x2(c2+x2C3)
+    mulsd   %xmm2, %xmm2                              # x4 recalculate
+    subsd   %xmm4, %xmm5                              # (1 + (-t)) - r
+    mulsd   %xmm3, %xmm1                              # x6(c4 + x2(c5+x2c6))
+    addsd   %xmm1, %xmm0                              # zc
+    subsd   .L__real_3ff0000000000000(%rip), %xmm4    # t relaculate
+    subsd   p_temp(%rsp), %xmm5                       # ((1 + (-t)) - r) - x*xx
+    mulsd   %xmm2, %xmm0                              # x4 * zc
+    addsd   %xmm5, %xmm0                              # x4 * zc + ((1 + (-t)) - r -x*xx)
+    subsd   %xmm4, %xmm0                              # result - (-t)
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+.align 32
+.Ladjust_region:        # positive or negative (0, 1, 2, 3)=>(1, 2, 3 ,4)=>(0, 2, 2,0)
+#      switch (region)
+    add     $1, %eax
+    and     $2, %eax
+    jz      .Lcos_cleanup
+## if the original region 1 or 2 then we negate the result.
+    movsd   %xmm0, %xmm2
+    xorpd   %xmm0, %xmm0
+    subsd   %xmm2, %xmm0
+
+.align 32
+.Lcos_cleanup:
+    add     $stack_size, %rsp
+    ret
+
+.align 32
+.Lcos_naninf:
+   call     fname_special
+   add      $stack_size, %rsp
+   ret
+
+
+
diff --git a/src/gas/cosf.S b/src/gas/cosf.S
new file mode 100644
index 0000000..43eae9a
--- /dev/null
+++ b/src/gas/cosf.S
@@ -0,0 +1,372 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+# An implementation of the cosf function.
+#
+# Prototype:
+#
+#     float fastcosf(float x);
+#
+#   Computes cosf(x).  
+#   Based on the NAG C implementation.
+#   It will provide proper C99 return values,
+#   but may not raise floating point status bits properly.
+#   Author: Harsha Jagasia
+#   Email:  harsha.jagasia@amd.com
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.data
+.align 32
+.L__real_3ff0000000000000: .quad 0x03ff0000000000000  # 1.0
+                        .quad 0                       # for alignment
+.L__real_3fe0000000000000: .quad 0x03fe0000000000000  # 0.5
+                        .quad 0
+.L__real_3fc5555555555555: .quad 0x03fc5555555555555  # 0.166666666666
+                        .quad 0
+.L__real_3fe45f306dc9c883: .quad 0x03fe45f306dc9c883  # twobypi
+                        .quad 0
+.L__real_3FF921FB54442D18: .quad 0x03FF921FB54442D18  # piby2
+                        .quad 0
+.L__real_3ff921fb54400000: .quad 0x03ff921fb54400000  # piby2_1
+                        .quad 0
+.L__real_3dd0b4611a626331: .quad 0x03dd0b4611a626331  # piby2_1tail
+                        .quad 0
+.L__real_3dd0b4611a600000: .quad 0x03dd0b4611a600000  # piby2_2
+                        .quad 0
+.L__real_3ba3198a2e037073: .quad 0x03ba3198a2e037073  # piby2_2tail
+                        .quad 0                                         
+.L__real_411E848000000000: .quad 0x415312d000000000   # 5e6 0x0411E848000000000  # 5e5
+                        .quad 0
+                        
+.align 32
+.Lcsarray:
+    .quad    0x0bfc5555555555555                      # -0.166667        s1
+    .quad    0x03fa5555555555555                      # 0.0416667        c1
+    .quad    0x03f81111111110bb3                      # 0.00833333       s2
+    .quad    0x0bf56c16c16c16967                      # -0.00138889      c2
+    .quad    0x0bf2a01a019e83e5c                      # -0.000198413     s3
+    .quad    0x03efa01a019f4ec90                      # 2.48016e-005     c3
+    .quad    0x03ec71de3796cde01                      # 2.75573e-006     s4
+    .quad    0x0be927e4fa17f65f6                      # -2.75573e-007    c4
+
+.text
+.align 32
+.p2align 5,,31
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(cosf)
+#define fname_special _cosf_special@PLT
+
+# define local variable storage offsets
+.equ    p_temp,    0x30                               # temporary for get/put bits operation
+.equ    p_temp1,   0x40                               # temporary for get/put bits operation
+.equ    region,    0x50                               # pointer to region for amd_remainder_piby2
+.equ    r,         0x60                               # pointer to r for amd_remainder_piby2
+.equ   stack_size, 0x88
+
+.globl fname
+.type  fname,@function
+
+fname:
+
+    sub     $stack_size, %rsp
+ 
+##  if NaN or inf
+    movd    %xmm0, %edx
+    mov     $0x07f800000, %eax
+    mov     %eax, %r10d
+    and     %edx, %r10d
+    cmp     %eax, %r10d
+    jz      .Lcosf_naninf
+   
+    xorpd   %xmm2, %xmm2
+    mov     %rdx, %r11                                # save 1st return value pointer
+
+#  GET_BITS_DP64(x, ux);
+# convert input to double.
+    cvtss2sd    %xmm0, %xmm0
+
+# get the input value to an integer register.
+    movsd   %xmm0,p_temp(%rsp)
+    mov     p_temp(%rsp), %rdx                        # rdx is ux
+
+#  ax = (ux & ~SIGNBIT_DP64);
+    mov     $0x07fffffffffffffff, %r10
+    and     %rdx, %r10                                # r10 is ax
+
+    mov     $1, %r8d                                  # for determining region later on
+    movsd   %xmm0, %xmm1                              # copy x to xmm1
+
+
+##  if (ax <= 0x3fe921fb54442d18) /* abs(x) <= pi/4 */
+    mov     $0x03fe921fb54442d18, %rax
+    cmp     %rax, %r10
+    jg      .L__sc_reducec
+
+#          *c = cos_piby4(x, 0.0);
+    movsd   %xmm0, %xmm2 
+    mulsd   %xmm2, %xmm2                              # x^2
+    xor     %eax, %eax
+    mov     %r10, %rdx
+    movsd   .L__real_3fe0000000000000(%rip), %xmm5    # .5
+    jmp     .L__sc_piby4c       
+    
+.align 32
+.L__sc_reducec:    
+# reduce  the argument to be in a range from -pi/4 to +pi/4
+# by subtracting multiples of pi/2
+#  xneg = (ax != ux);
+    cmp     %r10, %rdx
+##  if (xneg) x = -x;
+    jz      .Lpositive
+    subsd   %xmm0, %xmm2
+    movsd   %xmm2, %xmm0
+
+.Lpositive:
+##  if (x < 5.0e5)
+    cmp     .L__real_411E848000000000(%rip), %r10
+    jae     .Lcosf_reduce_precise
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+# perform taylor series to calc cosx, cosx
+# xmm0=abs(x), xmm1=x
+.align 32
+.Lcosf_piby4:
+#/* How many pi/2 is x a multiple of? */
+#        npi2  = (int)(x * twobypi + 0.5);
+
+    movsd   %xmm0, %xmm2
+    movsd   %xmm0, %xmm4
+
+    mulsd   .L__real_3fe45f306dc9c883(%rip), %xmm2    # twobypi
+    movsd   .L__real_3fe0000000000000(%rip), %xmm5    # .5 
+
+#/* How many pi/2 is x a multiple of? */
+
+#      xexp  = ax >> EXPSHIFTBITS_DP64;
+    mov     %r10, %r9
+    shr     $52, %r9                                  # >> EXPSHIFTBITS_DP64
+
+#        npi2  = (int)(x * twobypi + 0.5);
+    addsd   %xmm5, %xmm2                              # npi2
+    
+    movsd   .L__real_3ff921fb54400000(%rip), %xmm3    # piby2_1
+    cvttpd2dq    %xmm2, %xmm0                         # convert to integer 
+    movsd   .L__real_3dd0b4611a626331(%rip), %xmm1    # piby2_1tail    
+    cvtdq2pd    %xmm0, %xmm2                          # and back to double    
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+#      rhead  = x - npi2 * piby2_1;
+
+    mulsd   %xmm2, %xmm3                              # use piby2_1
+    subsd   %xmm3, %xmm4                              # rhead
+
+#      rtail  = npi2 * piby2_1tail;
+    mulsd   %xmm2, %xmm1                              # rtail
+    movd    %xmm0, %eax
+
+#      GET_BITS_DP64(rhead-rtail, uy);     
+    movsd   %xmm4, %xmm0
+    subsd   %xmm1, %xmm0
+
+    movsd   .L__real_3dd0b4611a600000(%rip), %xmm3    # piby2_2
+    movsd   .L__real_3ba3198a2e037073(%rip), %xmm5    # piby2_2tail
+    movd    %xmm0, %rcx                               # rcx is rhead-rtail
+
+#      expdiff = xexp - ((uy & EXPBITS_DP64) >> EXPSHIFTBITS_DP64);
+    shl     $1, %rcx                                  # strip any sign bit
+    shr     $53, %rcx                                 # >> EXPSHIFTBITS_DP64 +1
+    sub     %rcx, %r9                                 # expdiff
+
+##      if (expdiff > 15)
+    cmp     $15, %r9
+    jle     .Lexpdiffless15
+
+#          /* The remainder is pretty small compared with x, which
+#             implies that x is a near multiple of pi/2
+#             (x matches the multiple to at least 15 bits) */
+
+#          t  = rhead;
+    movsd   %xmm4, %xmm1
+
+#          rtail  = npi2 * piby2_2;
+    mulsd   %xmm2, %xmm3
+
+#          rhead  = t - rtail;
+    mulsd   %xmm2, %xmm5                              # npi2 * piby2_2tail
+    subsd   %xmm3, %xmm4                              # rhead
+
+#          rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+    subsd   %xmm4, %xmm1                              # t - rhead
+    subsd   %xmm3, %xmm1                              # -rtail
+    subsd   %xmm1, %xmm5                              # rtail
+
+#      r = rhead - rtail;
+    movsd   %xmm4, %xmm0
+
+#HARSHA
+#xmm1=rtail
+    movsd   %xmm5, %xmm1
+    subsd   %xmm5, %xmm0
+
+#    xmm0=r, xmm4=rhead, xmm1=rtail
+.Lexpdiffless15:
+#      region = npi2 & 3;
+
+    movsd   %xmm0, %xmm2 
+    mulsd   %xmm0, %xmm2        #x^2
+    movsd   %xmm0, %xmm1
+    movsd   .L__real_3fe0000000000000(%rip), %xmm5    # .5
+    
+    cmp     $0x03f2, %rcx                             # if r  small.
+    jge     .L__sc_piby4c                             # use taylor series if not
+    cmp     $0x03de, %rcx                             # if r really small.
+    jle     .L__rc_small                              # then cos(r) = 1
+
+##      if region is 1 or 3    do a sin calc.
+    and     %eax, %r8d
+    jz      .Lsinsmall
+# region 1 or 3
+# use simply polynomial
+#              *s = x - x*x*x*0.166666666666666666;
+    movsd   .L__real_3fc5555555555555(%rip), %xmm3    
+    mulsd   %xmm1, %xmm3                              # * x
+    mulsd   %xmm2, %xmm3                              # * x^2
+    subsd   %xmm3, %xmm1                              # xs
+    jmp     .L__adjust_region_cos
+    
+.align 16
+.Lsinsmall:
+# region 0 or 2
+#              cos = 1.0 - x*x*0.5;
+    movsd   .L__real_3ff0000000000000(%rip), %xmm1    # 1.0
+    mulsd   .L__real_3fe0000000000000(%rip), %xmm2    # 0.5 *x^2
+    subsd   %xmm2, %xmm1
+    jmp     .L__adjust_region_cos
+
+.align 16
+.L__rc_small:                                         # then sin(r) = r
+##     if region is 1 or 3   do a sin calc.
+   and      %eax, %r8d
+   jnz      .L__adjust_region_cos
+   movsd    .L__real_3ff0000000000000(%rip), %xmm1    # cos(r) is a 1 
+   jmp      .L__adjust_region_cos
+
+
+# done with reducing the argument.  Now perform the sin/cos calculations.
+.align 16
+.L__sc_piby4c:
+##     if region is 1 or 3   do a sin calc.
+   and      %eax, %r8d
+   jz       .Lcospiby4
+   
+   movsd    .Lcsarray+0x30(%rip), %xmm1               # c4
+   movsd    %xmm2, %xmm4
+   mulsd    %xmm2, %xmm1                              # x2c4
+   movsd    .Lcsarray+0x10(%rip), %xmm3               # c2
+   mulsd    %xmm4, %xmm4                              # x4   
+   mulsd    %xmm2, %xmm3                              # x2c2
+   mulsd    %xmm0, %xmm2                              # x3
+   addsd    .Lcsarray+0x20(%rip), %xmm1               # c3 + x2c4   
+   mulsd    %xmm4, %xmm1                              # x4(c3 + x2c4)
+   addsd    .Lcsarray(%rip), %xmm3                    # c1 + x2c2
+   addsd    %xmm3, %xmm1                              # c1 + c2x2 + c3x4 + c4x6
+   mulsd    %xmm2, %xmm1                              # c1x3 + c2x5 + c3x7 + c4x9
+   addsd    %xmm0, %xmm1                              # x + c1x3 + c2x5 + c3x7 + c4x9
+
+   jmp      .L__adjust_region_cos
+   
+.align 16
+.Lcospiby4:   
+# region 0 or 2    - do a cos calculation
+   movsd    .Lcsarray+0x38(%rip), %xmm1               # c4
+   movsd    %xmm2, %xmm4
+   mulsd    %xmm2, %xmm1                              # x2c4
+   movsd    .Lcsarray+0x18(%rip), %xmm3               # c2
+   mulsd    %xmm4, %xmm4                              # x4
+   mulsd    %xmm2, %xmm3                              # x2c2
+   mulsd    %xmm2, %xmm5                              # 0.5 * x2
+   addsd    .Lcsarray+0x28(%rip), %xmm1               # c3 + x2c4
+   mulsd    %xmm4, %xmm1                              # x4(c3 + x2c4)   
+   addsd    .Lcsarray+8(%rip), %xmm3                  # c1 + x2c2
+   addsd    %xmm3, %xmm1                              # c1 + x2c2 + c3x4 + c4x6
+   mulsd    %xmm4, %xmm1                              # x4(c1 + c2x2 + c3x4 + c4x6)
+
+#  -t = rc-1;
+   subsd    .L__real_3ff0000000000000(%rip), %xmm5    # 0.5x2 - 1
+   subsd    %xmm5, %xmm1                              # cos = 1 - 0.5x2 + c1x4 + c2x6 + c3x8 + c4x10
+
+.L__adjust_region_cos:                                # xmm1 is cos or sin, relies on previous sections to 
+#     switch (region)         
+   add      $1, %eax
+   and      $2, %eax
+   jz       .L__cos_cleanup
+## if region 1 or 2 then we negate the result.
+   xorpd    %xmm2, %xmm2
+   subsd    %xmm1, %xmm2
+   movsd    %xmm2, %xmm1
+
+.align 16   
+.L__cos_cleanup:
+   cvtsd2ss %xmm1, %xmm0
+   add      $stack_size, %rsp
+   ret
+
+.align 16
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lcosf_reduce_precise:
+#     /* Reduce abs(x) into range [-pi/4,pi/4] */
+#     __amd_remainder_piby2(ax, &r, &region);
+
+   mov      %rdx,p_temp(%rsp)                         # save ux for use later
+   mov      %r10,p_temp1(%rsp)                        # save ax for use later
+   movd     %xmm0, %rdi
+   lea      r(%rsp), %rsi
+   lea      region(%rsp), %rdx
+   sub      $0x020, %rsp   
+
+   call     __amd_remainder_piby2d2f@PLT
+
+   add      $0x020, %rsp
+   mov      p_temp(%rsp), %rdx                        # restore ux for use later
+   mov      p_temp1(%rsp), %r10                       # restore ax for use later   
+   mov      $1, %r8d                                  # for determining region later on
+   movsd    r(%rsp), %xmm0                            # r
+   mov      region(%rsp), %eax                        # region
+
+   movsd    %xmm0, %xmm2 
+   mulsd    %xmm0, %xmm2                              # x^2
+   movsd    %xmm0, %xmm1
+   movsd    .L__real_3fe0000000000000(%rip), %xmm5    # .5
+
+   jmp      .L__sc_piby4c
+
+.align 32
+.Lcosf_naninf:
+   call     fname_special
+   add      $stack_size, %rsp
+   ret
diff --git a/src/gas/exp.S b/src/gas/exp.S
new file mode 100644
index 0000000..153e8a6
--- /dev/null
+++ b/src/gas/exp.S
@@ -0,0 +1,400 @@
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+#ifdef __x86_64__
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#
+# exp.S
+#
+# An implementation of the exp libm function.
+#
+# Prototype:
+#
+#     double exp(double x);
+#
+
+#
+#   Algorithm:
+#   
+#   e^x = 2^(x/ln(2)) = 2^(x*(64/ln(2))/64)
+#
+#   x*(64/ln(2)) = n + f, |f| <= 0.5, n is integer
+#   n = 64*m + j,   0 <= j < 64
+#   
+#   e^x = 2^((64*m + j + f)/64)
+#       = (2^m) * (2^(j/64)) * 2^(f/64)
+#       = (2^m) * (2^(j/64)) * e^(f*(ln(2)/64))
+#
+#   f = x*(64/ln(2)) - n
+#   r = f*(ln(2)/64) = x - n*(ln(2)/64)
+#
+#   e^x = (2^m) * (2^(j/64)) * e^r
+#
+#   (2^(j/64)) is precomputed
+#
+#   e^r = 1 + r + (r^2)/2! + (r^3)/3! + (r^4)/4! + (r^5)/5! + (r^5)/5!
+#   e^r = 1 + q
+#
+#   q = r + (r^2)/2! + (r^3)/3! + (r^4)/4! + (r^5)/5! + (r^5)/5!
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(exp)
+#define fname_special _exp_special@PLT
+
+.text
+.p2align 4
+.globl fname
+.type fname,@function
+fname:
+    ucomisd      .L__max_exp_arg(%rip), %xmm0
+    ja           .L__y_is_inf
+    jp           .L__y_is_nan
+    ucomisd      .L__denormal_tiny_threshold(%rip), %xmm0
+    jbe          .L__y_is_zero
+
+    # x * (64/ln(2))
+    movapd      %xmm0,%xmm1        
+    mulsd       .L__real_64_by_log2(%rip), %xmm1
+
+    # n = int( x * (64/ln(2)) )
+    cvttpd2dq    %xmm1, %xmm2   #xmm2 = (int)n
+    cvtdq2pd    %xmm2, %xmm1   #xmm1 = (double)n
+    movd        %xmm2, %ecx
+    movapd     %xmm1,%xmm2
+    # r1 = x - n * ln(2)/64 head    
+    mulsd    .L__log2_by_64_mhead(%rip),%xmm1
+        
+    #j = n & 0x3f    
+    mov         $0x3f, %rax
+    and         %ecx, %eax     #eax = j
+    # m = (n - j) / 64      
+    sar         $6, %ecx       #ecx = m
+        
+
+    # r2 = - n * ln(2)/64 tail
+    mulsd    .L__log2_by_64_mtail(%rip),%xmm2
+    addsd    %xmm1,%xmm0   #xmm0 = r1
+
+    # r1+r2
+    addsd       %xmm0, %xmm2 #xmm2 = r
+
+    # q = r + r^2*1/2 + r^3*1/6 + r^4 *1/24 + r^5*1/120 + r^6*1/720
+    # q = r + r*r*(1/2 + r*(1/6+ r*(1/24 + r*(1/120 + r*(1/720)))))
+    movapd       .L__real_1_by_720(%rip), %xmm3  #xmm3 = 1/720
+    mulsd       %xmm2, %xmm3    #xmm3 = r*1/720
+    movapd       .L__real_1_by_6(%rip), %xmm0    #xmm0 = 1/6    
+    movapd      %xmm2, %xmm1 #xmm1 = r            
+    mulsd       %xmm2, %xmm0    #xmm0 = r*1/6
+    addsd       .L__real_1_by_120(%rip), %xmm3  #xmm3 = 1/120 + (r*1/720)
+    mulsd       %xmm2, %xmm1    #xmm1 = r*r    
+    addsd       .L__real_1_by_2(%rip), %xmm0  #xmm0 = 1/2 + (r*1/6)        
+    movapd       %xmm1, %xmm4   #xmm4 = r*r
+    mulsd       %xmm1, %xmm4    #xmm4 = (r*r) * (r*r)    
+    mulsd       %xmm2, %xmm3    #xmm3 = r * (1/120 + (r*1/720))
+    mulsd       %xmm1, %xmm0    #xmm0 = (r*r)*(1/2 + (r*1/6))
+    addsd       .L__real_1_by_24(%rip), %xmm3  #xmm3 = 1/24 + (r * (1/120 + (r*1/720)))
+    addsd       %xmm2, %xmm0   #xmm0 = r + ((r*r)*(1/2 + (r*1/6)))
+    mulsd       %xmm4, %xmm3   #xmm3 = ((r*r) * (r*r)) * (1/24 + (r * (1/120 + (r*1/720))))
+    addsd       %xmm3, %xmm0   #xmm0 = r + ((r*r)*(1/2 + (r*1/6))) + ((r*r) * (r*r)) * (1/24 + (r * (1/120 + (r*1/720))))
+    
+    # (f)*(q) + f2 + f1
+    cmp         $0xfffffc02, %ecx # -1022    
+    lea         .L__two_to_jby64_table(%rip), %rdx        
+    lea         .L__two_to_jby64_tail_table(%rip), %r11       
+    lea         .L__two_to_jby64_head_table(%rip), %r10      
+    mulsd       (%rdx,%rax,8), %xmm0
+    addsd       (%r11,%rax,8), %xmm0
+    addsd       (%r10,%rax,8), %xmm0        
+
+    jle         .L__process_denormal 
+.L__process_normal:
+    shl         $52, %rcx    
+    movd        %rcx,%xmm2
+    paddq       %xmm2, %xmm0
+    ret
+
+.p2align 4
+.L__process_denormal:
+    jl          .L__process_true_denormal
+    ucomisd     .L__real_one(%rip), %xmm0
+    jae         .L__process_normal
+.L__process_true_denormal:
+    # here ( e^r < 1 and m = -1022 ) or m <= -1023
+    add         $1074, %ecx
+    mov         $1, %rax    
+    shl         %cl, %rax
+    movd         %rax, %xmm2
+    mulsd       %xmm2, %xmm0
+    ret        
+    
+.p2align 4
+.L__y_is_inf:
+    mov         $0x7ff0000000000000,%rax
+    movd       %rax, %xmm1
+    mov         $3, %edi
+    jmp         fname_special
+
+.p2align 4
+.L__y_is_nan:
+    movapd      %xmm0,%xmm1
+    addsd       %xmm0,%xmm1
+    mov         $1, %edi
+    jmp         fname_special
+
+.p2align 4
+.L__y_is_zero:
+    ucomisd     .L__min_exp_arg(%rip),%xmm0
+    jbe          .L__return_zero
+    movapd       .L__real_smallest_denormal(%rip), %xmm0
+    ret
+    
+.p2align 4        
+.L__return_zero:    
+    pxor        %xmm1,%xmm1
+    mov         $2, %edi
+    jmp         fname_special
+    
+.data
+.align 16
+.L__max_exp_arg:            .quad 0x40862e42fefa39ef
+.L__denormal_tiny_threshold:  .quad 0xc0874046dfefd9d0
+.L__min_exp_arg:            .quad 0xc0874910d52d3051
+.L__real_64_by_log2:        .quad 0x40571547652b82fe    # 64/ln(2)
+
+.align 16
+.L__log2_by_64_mhead: .quad 0xbf862e42fefa0000
+.L__log2_by_64_mtail: .quad 0xbd1cf79abc9e3b39
+.L__real_1_by_720:              .quad 0x3f56c16c16c16c17    # 1/720
+.L__real_1_by_120:              .quad 0x3f81111111111111    # 1/120
+.L__real_1_by_6:                .quad 0x3fc5555555555555    # 1/6
+.L__real_1_by_2:                .quad 0x3fe0000000000000    # 1/2
+.L__real_1_by_24:               .quad 0x3fa5555555555555    # 1/24
+.L__real_one:                   .quad 0x3ff0000000000000
+.L__real_smallest_denormal:     .quad 0x0000000000000001
+
+
+.align 16
+.L__two_to_jby64_table:
+    .quad 0x3ff0000000000000
+    .quad 0x3ff02c9a3e778061
+    .quad 0x3ff059b0d3158574
+    .quad 0x3ff0874518759bc8
+    .quad 0x3ff0b5586cf9890f
+    .quad 0x3ff0e3ec32d3d1a2
+    .quad 0x3ff11301d0125b51
+    .quad 0x3ff1429aaea92de0
+    .quad 0x3ff172b83c7d517b
+    .quad 0x3ff1a35beb6fcb75
+    .quad 0x3ff1d4873168b9aa
+    .quad 0x3ff2063b88628cd6
+    .quad 0x3ff2387a6e756238
+    .quad 0x3ff26b4565e27cdd
+    .quad 0x3ff29e9df51fdee1
+    .quad 0x3ff2d285a6e4030b
+    .quad 0x3ff306fe0a31b715
+    .quad 0x3ff33c08b26416ff
+    .quad 0x3ff371a7373aa9cb
+    .quad 0x3ff3a7db34e59ff7
+    .quad 0x3ff3dea64c123422
+    .quad 0x3ff4160a21f72e2a
+    .quad 0x3ff44e086061892d
+    .quad 0x3ff486a2b5c13cd0
+    .quad 0x3ff4bfdad5362a27
+    .quad 0x3ff4f9b2769d2ca7
+    .quad 0x3ff5342b569d4f82
+    .quad 0x3ff56f4736b527da
+    .quad 0x3ff5ab07dd485429
+    .quad 0x3ff5e76f15ad2148
+    .quad 0x3ff6247eb03a5585
+    .quad 0x3ff6623882552225
+    .quad 0x3ff6a09e667f3bcd
+    .quad 0x3ff6dfb23c651a2f
+    .quad 0x3ff71f75e8ec5f74
+    .quad 0x3ff75feb564267c9
+    .quad 0x3ff7a11473eb0187
+    .quad 0x3ff7e2f336cf4e62
+    .quad 0x3ff82589994cce13
+    .quad 0x3ff868d99b4492ed
+    .quad 0x3ff8ace5422aa0db
+    .quad 0x3ff8f1ae99157736
+    .quad 0x3ff93737b0cdc5e5
+    .quad 0x3ff97d829fde4e50
+    .quad 0x3ff9c49182a3f090
+    .quad 0x3ffa0c667b5de565
+    .quad 0x3ffa5503b23e255d
+    .quad 0x3ffa9e6b5579fdbf
+    .quad 0x3ffae89f995ad3ad
+    .quad 0x3ffb33a2b84f15fb
+    .quad 0x3ffb7f76f2fb5e47
+    .quad 0x3ffbcc1e904bc1d2
+    .quad 0x3ffc199bdd85529c
+    .quad 0x3ffc67f12e57d14b
+    .quad 0x3ffcb720dcef9069
+    .quad 0x3ffd072d4a07897c
+    .quad 0x3ffd5818dcfba487
+    .quad 0x3ffda9e603db3285
+    .quad 0x3ffdfc97337b9b5f
+    .quad 0x3ffe502ee78b3ff6
+    .quad 0x3ffea4afa2a490da
+    .quad 0x3ffefa1bee615a27
+    .quad 0x3fff50765b6e4540
+    .quad 0x3fffa7c1819e90d8
+
+.align 16
+.L__two_to_jby64_head_table:
+    .quad 0x3ff0000000000000
+    .quad 0x3ff02c9a30000000
+    .quad 0x3ff059b0d0000000
+    .quad 0x3ff0874510000000
+    .quad 0x3ff0b55860000000
+    .quad 0x3ff0e3ec30000000
+    .quad 0x3ff11301d0000000
+    .quad 0x3ff1429aa0000000
+    .quad 0x3ff172b830000000
+    .quad 0x3ff1a35be0000000
+    .quad 0x3ff1d48730000000
+    .quad 0x3ff2063b80000000
+    .quad 0x3ff2387a60000000
+    .quad 0x3ff26b4560000000
+    .quad 0x3ff29e9df0000000
+    .quad 0x3ff2d285a0000000
+    .quad 0x3ff306fe00000000
+    .quad 0x3ff33c08b0000000
+    .quad 0x3ff371a730000000
+    .quad 0x3ff3a7db30000000
+    .quad 0x3ff3dea640000000
+    .quad 0x3ff4160a20000000
+    .quad 0x3ff44e0860000000
+    .quad 0x3ff486a2b0000000
+    .quad 0x3ff4bfdad0000000
+    .quad 0x3ff4f9b270000000
+    .quad 0x3ff5342b50000000
+    .quad 0x3ff56f4730000000
+    .quad 0x3ff5ab07d0000000
+    .quad 0x3ff5e76f10000000
+    .quad 0x3ff6247eb0000000
+    .quad 0x3ff6623880000000
+    .quad 0x3ff6a09e60000000
+    .quad 0x3ff6dfb230000000
+    .quad 0x3ff71f75e0000000
+    .quad 0x3ff75feb50000000
+    .quad 0x3ff7a11470000000
+    .quad 0x3ff7e2f330000000
+    .quad 0x3ff8258990000000
+    .quad 0x3ff868d990000000
+    .quad 0x3ff8ace540000000
+    .quad 0x3ff8f1ae90000000
+    .quad 0x3ff93737b0000000
+    .quad 0x3ff97d8290000000
+    .quad 0x3ff9c49180000000
+    .quad 0x3ffa0c6670000000
+    .quad 0x3ffa5503b0000000
+    .quad 0x3ffa9e6b50000000
+    .quad 0x3ffae89f90000000
+    .quad 0x3ffb33a2b0000000
+    .quad 0x3ffb7f76f0000000
+    .quad 0x3ffbcc1e90000000
+    .quad 0x3ffc199bd0000000
+    .quad 0x3ffc67f120000000
+    .quad 0x3ffcb720d0000000
+    .quad 0x3ffd072d40000000
+    .quad 0x3ffd5818d0000000
+    .quad 0x3ffda9e600000000
+    .quad 0x3ffdfc9730000000
+    .quad 0x3ffe502ee0000000
+    .quad 0x3ffea4afa0000000
+    .quad 0x3ffefa1be0000000
+    .quad 0x3fff507650000000
+    .quad 0x3fffa7c180000000
+
+.align 16
+.L__two_to_jby64_tail_table:
+    .quad 0x0000000000000000
+    .quad 0x3e6cef00c1dcdef9
+    .quad 0x3e48ac2ba1d73e2a
+    .quad 0x3e60eb37901186be
+    .quad 0x3e69f3121ec53172
+    .quad 0x3e469e8d10103a17
+    .quad 0x3df25b50a4ebbf1a
+    .quad 0x3e6d525bbf668203
+    .quad 0x3e68faa2f5b9bef9
+    .quad 0x3e66df96ea796d31
+    .quad 0x3e368b9aa7805b80
+    .quad 0x3e60c519ac771dd6
+    .quad 0x3e6ceac470cd83f5
+    .quad 0x3e5789f37495e99c
+    .quad 0x3e547f7b84b09745
+    .quad 0x3e5b900c2d002475
+    .quad 0x3e64636e2a5bd1ab
+    .quad 0x3e4320b7fa64e430
+    .quad 0x3e5ceaa72a9c5154
+    .quad 0x3e53967fdba86f24
+    .quad 0x3e682468446b6824
+    .quad 0x3e3f72e29f84325b
+    .quad 0x3e18624b40c4dbd0
+    .quad 0x3e5704f3404f068e
+    .quad 0x3e54d8a89c750e5e
+    .quad 0x3e5a74b29ab4cf62
+    .quad 0x3e5a753e077c2a0f
+    .quad 0x3e5ad49f699bb2c0
+    .quad 0x3e6a90a852b19260
+    .quad 0x3e56b48521ba6f93
+    .quad 0x3e0d2ac258f87d03
+    .quad 0x3e42a91124893ecf
+    .quad 0x3e59fcef32422cbe
+    .quad 0x3e68ca345de441c5
+    .quad 0x3e61d8bee7ba46e1
+    .quad 0x3e59099f22fdba6a
+    .quad 0x3e4f580c36bea881
+    .quad 0x3e5b3d398841740a
+    .quad 0x3e62999c25159f11
+    .quad 0x3e668925d901c83b
+    .quad 0x3e415506dadd3e2a
+    .quad 0x3e622aee6c57304e
+    .quad 0x3e29b8bc9e8a0387
+    .quad 0x3e6fbc9c9f173d24
+    .quad 0x3e451f8480e3e235
+    .quad 0x3e66bbcac96535b5
+    .quad 0x3e41f12ae45a1224
+    .quad 0x3e55e7f6fd0fac90
+    .quad 0x3e62b5a75abd0e69
+    .quad 0x3e609e2bf5ed7fa1
+    .quad 0x3e47daf237553d84
+    .quad 0x3e12f074891ee83d
+    .quad 0x3e6b0aa538444196
+    .quad 0x3e6cafa29694426f
+    .quad 0x3e69df20d22a0797
+    .quad 0x3e640f12f71a1e45
+    .quad 0x3e69f7490e4bb40b
+    .quad 0x3e4ed9942b84600d
+    .quad 0x3e4bdcdaf5cb4656
+    .quad 0x3e5e2cffd89cf44c
+    .quad 0x3e452486cc2c7b9d
+    .quad 0x3e6cc2b44eee3fa4
+    .quad 0x3e66dc8a80ce9f09
+    .quad 0x3e39e90d82e90a7e
+
+#endif
diff --git a/src/gas/exp10.S b/src/gas/exp10.S
new file mode 100644
index 0000000..009bbe0
--- /dev/null
+++ b/src/gas/exp10.S
@@ -0,0 +1,366 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(exp10)
+#define fname_special _exp10_special@PLT
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.p2align 4
+.globl fname
+.type fname,@function
+fname:
+    ucomisd      .L__max_exp10_arg(%rip), %xmm0
+    jae          .L__y_is_inf
+    jp           .L__y_is_nan
+    ucomisd      .L__min_exp10_arg(%rip), %xmm0
+    jbe          .L__y_is_zero
+
+    # x * (64/log10(2))
+    movapd      %xmm0,%xmm1        
+    mulsd       .L__real_64_by_log10of2(%rip), %xmm1
+
+    # n = int( x * (64/log10(2)) )
+    cvttpd2dq    %xmm1, %xmm2   #xmm2 = (int)n
+    cvtdq2pd    %xmm2, %xmm1   #xmm1 = (double)n
+    movd        %xmm2, %ecx
+    movapd     %xmm1,%xmm2
+    # r1 = x - n * log10(2)/64 head    
+    mulsd    .L__log10of2_by_64_mhead(%rip),%xmm1
+        
+    #j = n & 0x3f    
+    mov         $0x3f, %rax
+    and         %ecx, %eax     #eax = j
+    # m = (n - j) / 64      
+    sar         $6, %ecx       #ecx = m        
+
+    # r2 = - n * log10(2)/64 tail
+    mulsd    .L__log10of2_by_64_mtail(%rip),%xmm2 #xmm2 = r2
+    addsd    %xmm1,%xmm0   #xmm0 = r1
+    
+    # r1 *= ln10;
+    # r2 *= ln10;
+    mulsd   .L__ln10(%rip),%xmm0
+    mulsd   .L__ln10(%rip),%xmm2
+
+    # r1+r2
+    addsd       %xmm0, %xmm2 #xmm2 = r
+
+    # q = r + r^2*1/2 + r^3*1/6 + r^4 *1/24 + r^5*1/120 + r^6*1/720
+    # q = r + r*r*(1/2 + r*(1/6+ r*(1/24 + r*(1/120 + r*(1/720)))))
+    movapd       .L__real_1_by_720(%rip), %xmm3  #xmm3 = 1/720
+    mulsd       %xmm2, %xmm3    #xmm3 = r*1/720
+    movapd       .L__real_1_by_6(%rip), %xmm0    #xmm0 = 1/6    
+    movapd      %xmm2, %xmm1 #xmm1 = r            
+    mulsd       %xmm2, %xmm0    #xmm0 = r*1/6
+    addsd       .L__real_1_by_120(%rip), %xmm3  #xmm3 = 1/120 + (r*1/720)
+    mulsd       %xmm2, %xmm1    #xmm1 = r*r    
+    addsd       .L__real_1_by_2(%rip), %xmm0  #xmm0 = 1/2 + (r*1/6)        
+    movapd       %xmm1, %xmm4   #xmm4 = r*r
+    mulsd       %xmm1, %xmm4    #xmm4 = (r*r) * (r*r)    
+    mulsd       %xmm2, %xmm3    #xmm3 = r * (1/120 + (r*1/720))
+    mulsd       %xmm1, %xmm0    #xmm0 = (r*r)*(1/2 + (r*1/6))
+    addsd       .L__real_1_by_24(%rip), %xmm3  #xmm3 = 1/24 + (r * (1/120 + (r*1/720)))
+    addsd       %xmm2, %xmm0   #xmm0 = r + ((r*r)*(1/2 + (r*1/6)))
+    mulsd       %xmm4, %xmm3   #xmm3 = ((r*r) * (r*r)) * (1/24 + (r * (1/120 + (r*1/720))))
+    addsd       %xmm3, %xmm0   #xmm0 = r + ((r*r)*(1/2 + (r*1/6))) + ((r*r) * (r*r)) * (1/24 + (r * (1/120 + (r*1/720))))
+    
+    # (f)*(q) + f2 + f1
+    cmp         $0xfffffc02, %ecx # -1022    
+    lea         .L__two_to_jby64_table(%rip), %rdx        
+    lea         .L__two_to_jby64_tail_table(%rip), %r11       
+    lea         .L__two_to_jby64_head_table(%rip), %r10      
+    mulsd       (%rdx,%rax,8), %xmm0
+    addsd       (%r11,%rax,8), %xmm0
+    addsd       (%r10,%rax,8), %xmm0        
+
+    jle         .L__process_denormal 
+.L__process_normal:
+    shl         $52, %rcx    
+    movd        %rcx,%xmm2
+    paddq       %xmm2, %xmm0
+    ret
+
+.p2align 4
+.L__process_denormal:
+    jl          .L__process_true_denormal
+    ucomisd     .L__real_one(%rip), %xmm0
+    jae         .L__process_normal
+.L__process_true_denormal:
+    # here ( e^r < 1 and m = -1022 ) or m <= -1023
+    add         $1074, %ecx
+    mov         $1, %rax    
+    shl         %cl, %rax
+    movd         %rax, %xmm2
+    mulsd       %xmm2, %xmm0
+    ret        
+    
+.p2align 4
+.L__y_is_inf:
+    mov         $0x7ff0000000000000,%rax
+    movd       %rax, %xmm1
+    mov         $3, %edi
+    #call        fname_special
+    movdqa %xmm1,%xmm0 #remove this if call is made
+    ret     
+
+.p2align 4
+.L__y_is_nan:
+    movapd      %xmm0,%xmm1
+    addsd       %xmm0,%xmm1
+    mov         $1, %edi
+    #call        fname_special
+    movdqa %xmm1,%xmm0 #remove this if call is made    
+    ret
+
+.p2align 4
+.L__y_is_zero:
+    pxor        %xmm1,%xmm1
+    mov         $2, %edi
+    #call        fname_special
+    movdqa %xmm1,%xmm0 #remove this if call is made    
+    ret      
+    
+.data
+.align 16
+.L__max_exp10_arg:          .quad 0x40734413509f79ff
+.L__min_exp10_arg:            .quad 0xc07434e6420f4374
+.L__real_64_by_log10of2:    .quad 0x406A934F0979A371    # 64/log10(2)
+.L__ln10:                   .quad 0x40026BB1BBB55516
+
+.align 16
+.L__log10of2_by_64_mhead: .quad 0xbF73441350000000
+.L__log10of2_by_64_mtail: .quad 0xbda3ef3fde623e25
+.L__real_1_by_720:              .quad 0x3f56c16c16c16c17    # 1/720
+.L__real_1_by_120:              .quad 0x3f81111111111111    # 1/120
+.L__real_1_by_6:                .quad 0x3fc5555555555555    # 1/6
+.L__real_1_by_2:                .quad 0x3fe0000000000000    # 1/2
+.L__real_1_by_24:               .quad 0x3fa5555555555555    # 1/24
+.L__real_one:                   .quad 0x3ff0000000000000
+
+.align 16
+.L__two_to_jby64_table:
+    .quad 0x3ff0000000000000
+    .quad 0x3ff02c9a3e778061
+    .quad 0x3ff059b0d3158574
+    .quad 0x3ff0874518759bc8
+    .quad 0x3ff0b5586cf9890f
+    .quad 0x3ff0e3ec32d3d1a2
+    .quad 0x3ff11301d0125b51
+    .quad 0x3ff1429aaea92de0
+    .quad 0x3ff172b83c7d517b
+    .quad 0x3ff1a35beb6fcb75
+    .quad 0x3ff1d4873168b9aa
+    .quad 0x3ff2063b88628cd6
+    .quad 0x3ff2387a6e756238
+    .quad 0x3ff26b4565e27cdd
+    .quad 0x3ff29e9df51fdee1
+    .quad 0x3ff2d285a6e4030b
+    .quad 0x3ff306fe0a31b715
+    .quad 0x3ff33c08b26416ff
+    .quad 0x3ff371a7373aa9cb
+    .quad 0x3ff3a7db34e59ff7
+    .quad 0x3ff3dea64c123422
+    .quad 0x3ff4160a21f72e2a
+    .quad 0x3ff44e086061892d
+    .quad 0x3ff486a2b5c13cd0
+    .quad 0x3ff4bfdad5362a27
+    .quad 0x3ff4f9b2769d2ca7
+    .quad 0x3ff5342b569d4f82
+    .quad 0x3ff56f4736b527da
+    .quad 0x3ff5ab07dd485429
+    .quad 0x3ff5e76f15ad2148
+    .quad 0x3ff6247eb03a5585
+    .quad 0x3ff6623882552225
+    .quad 0x3ff6a09e667f3bcd
+    .quad 0x3ff6dfb23c651a2f
+    .quad 0x3ff71f75e8ec5f74
+    .quad 0x3ff75feb564267c9
+    .quad 0x3ff7a11473eb0187
+    .quad 0x3ff7e2f336cf4e62
+    .quad 0x3ff82589994cce13
+    .quad 0x3ff868d99b4492ed
+    .quad 0x3ff8ace5422aa0db
+    .quad 0x3ff8f1ae99157736
+    .quad 0x3ff93737b0cdc5e5
+    .quad 0x3ff97d829fde4e50
+    .quad 0x3ff9c49182a3f090
+    .quad 0x3ffa0c667b5de565
+    .quad 0x3ffa5503b23e255d
+    .quad 0x3ffa9e6b5579fdbf
+    .quad 0x3ffae89f995ad3ad
+    .quad 0x3ffb33a2b84f15fb
+    .quad 0x3ffb7f76f2fb5e47
+    .quad 0x3ffbcc1e904bc1d2
+    .quad 0x3ffc199bdd85529c
+    .quad 0x3ffc67f12e57d14b
+    .quad 0x3ffcb720dcef9069
+    .quad 0x3ffd072d4a07897c
+    .quad 0x3ffd5818dcfba487
+    .quad 0x3ffda9e603db3285
+    .quad 0x3ffdfc97337b9b5f
+    .quad 0x3ffe502ee78b3ff6
+    .quad 0x3ffea4afa2a490da
+    .quad 0x3ffefa1bee615a27
+    .quad 0x3fff50765b6e4540
+    .quad 0x3fffa7c1819e90d8
+
+.align 16
+.L__two_to_jby64_head_table:
+    .quad 0x3ff0000000000000
+    .quad 0x3ff02c9a30000000
+    .quad 0x3ff059b0d0000000
+    .quad 0x3ff0874510000000
+    .quad 0x3ff0b55860000000
+    .quad 0x3ff0e3ec30000000
+    .quad 0x3ff11301d0000000
+    .quad 0x3ff1429aa0000000
+    .quad 0x3ff172b830000000
+    .quad 0x3ff1a35be0000000
+    .quad 0x3ff1d48730000000
+    .quad 0x3ff2063b80000000
+    .quad 0x3ff2387a60000000
+    .quad 0x3ff26b4560000000
+    .quad 0x3ff29e9df0000000
+    .quad 0x3ff2d285a0000000
+    .quad 0x3ff306fe00000000
+    .quad 0x3ff33c08b0000000
+    .quad 0x3ff371a730000000
+    .quad 0x3ff3a7db30000000
+    .quad 0x3ff3dea640000000
+    .quad 0x3ff4160a20000000
+    .quad 0x3ff44e0860000000
+    .quad 0x3ff486a2b0000000
+    .quad 0x3ff4bfdad0000000
+    .quad 0x3ff4f9b270000000
+    .quad 0x3ff5342b50000000
+    .quad 0x3ff56f4730000000
+    .quad 0x3ff5ab07d0000000
+    .quad 0x3ff5e76f10000000
+    .quad 0x3ff6247eb0000000
+    .quad 0x3ff6623880000000
+    .quad 0x3ff6a09e60000000
+    .quad 0x3ff6dfb230000000
+    .quad 0x3ff71f75e0000000
+    .quad 0x3ff75feb50000000
+    .quad 0x3ff7a11470000000
+    .quad 0x3ff7e2f330000000
+    .quad 0x3ff8258990000000
+    .quad 0x3ff868d990000000
+    .quad 0x3ff8ace540000000
+    .quad 0x3ff8f1ae90000000
+    .quad 0x3ff93737b0000000
+    .quad 0x3ff97d8290000000
+    .quad 0x3ff9c49180000000
+    .quad 0x3ffa0c6670000000
+    .quad 0x3ffa5503b0000000
+    .quad 0x3ffa9e6b50000000
+    .quad 0x3ffae89f90000000
+    .quad 0x3ffb33a2b0000000
+    .quad 0x3ffb7f76f0000000
+    .quad 0x3ffbcc1e90000000
+    .quad 0x3ffc199bd0000000
+    .quad 0x3ffc67f120000000
+    .quad 0x3ffcb720d0000000
+    .quad 0x3ffd072d40000000
+    .quad 0x3ffd5818d0000000
+    .quad 0x3ffda9e600000000
+    .quad 0x3ffdfc9730000000
+    .quad 0x3ffe502ee0000000
+    .quad 0x3ffea4afa0000000
+    .quad 0x3ffefa1be0000000
+    .quad 0x3fff507650000000
+    .quad 0x3fffa7c180000000
+
+.align 16
+.L__two_to_jby64_tail_table:
+    .quad 0x0000000000000000
+    .quad 0x3e6cef00c1dcdef9
+    .quad 0x3e48ac2ba1d73e2a
+    .quad 0x3e60eb37901186be
+    .quad 0x3e69f3121ec53172
+    .quad 0x3e469e8d10103a17
+    .quad 0x3df25b50a4ebbf1a
+    .quad 0x3e6d525bbf668203
+    .quad 0x3e68faa2f5b9bef9
+    .quad 0x3e66df96ea796d31
+    .quad 0x3e368b9aa7805b80
+    .quad 0x3e60c519ac771dd6
+    .quad 0x3e6ceac470cd83f5
+    .quad 0x3e5789f37495e99c
+    .quad 0x3e547f7b84b09745
+    .quad 0x3e5b900c2d002475
+    .quad 0x3e64636e2a5bd1ab
+    .quad 0x3e4320b7fa64e430
+    .quad 0x3e5ceaa72a9c5154
+    .quad 0x3e53967fdba86f24
+    .quad 0x3e682468446b6824
+    .quad 0x3e3f72e29f84325b
+    .quad 0x3e18624b40c4dbd0
+    .quad 0x3e5704f3404f068e
+    .quad 0x3e54d8a89c750e5e
+    .quad 0x3e5a74b29ab4cf62
+    .quad 0x3e5a753e077c2a0f
+    .quad 0x3e5ad49f699bb2c0
+    .quad 0x3e6a90a852b19260
+    .quad 0x3e56b48521ba6f93
+    .quad 0x3e0d2ac258f87d03
+    .quad 0x3e42a91124893ecf
+    .quad 0x3e59fcef32422cbe
+    .quad 0x3e68ca345de441c5
+    .quad 0x3e61d8bee7ba46e1
+    .quad 0x3e59099f22fdba6a
+    .quad 0x3e4f580c36bea881
+    .quad 0x3e5b3d398841740a
+    .quad 0x3e62999c25159f11
+    .quad 0x3e668925d901c83b
+    .quad 0x3e415506dadd3e2a
+    .quad 0x3e622aee6c57304e
+    .quad 0x3e29b8bc9e8a0387
+    .quad 0x3e6fbc9c9f173d24
+    .quad 0x3e451f8480e3e235
+    .quad 0x3e66bbcac96535b5
+    .quad 0x3e41f12ae45a1224
+    .quad 0x3e55e7f6fd0fac90
+    .quad 0x3e62b5a75abd0e69
+    .quad 0x3e609e2bf5ed7fa1
+    .quad 0x3e47daf237553d84
+    .quad 0x3e12f074891ee83d
+    .quad 0x3e6b0aa538444196
+    .quad 0x3e6cafa29694426f
+    .quad 0x3e69df20d22a0797
+    .quad 0x3e640f12f71a1e45
+    .quad 0x3e69f7490e4bb40b
+    .quad 0x3e4ed9942b84600d
+    .quad 0x3e4bdcdaf5cb4656
+    .quad 0x3e5e2cffd89cf44c
+    .quad 0x3e452486cc2c7b9d
+    .quad 0x3e6cc2b44eee3fa4
+    .quad 0x3e66dc8a80ce9f09
+    .quad 0x3e39e90d82e90a7e
+
+
+
diff --git a/src/gas/exp10f.S b/src/gas/exp10f.S
new file mode 100644
index 0000000..da805e2
--- /dev/null
+++ b/src/gas/exp10f.S
@@ -0,0 +1,191 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(exp10f)
+#define fname_special _exp10f_special@PLT
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.p2align 4
+.globl fname
+.type fname,@function
+fname:
+    ucomiss .L__max_exp_arg(%rip), %xmm0
+    ja .L__y_is_inf
+    jp .L__y_is_nan
+    ucomiss .L__min_exp_arg(%rip), %xmm0
+    jb .L__y_is_zero
+
+    cvtps2pd     %xmm0, %xmm0    #xmm0 = (double)x
+
+    # x * (64/log10of(2))
+    movapd      %xmm0,%xmm3      #xmm3 = (xouble)x
+    mulsd       .L__real_64_by_log10of2(%rip), %xmm3  #xmm3 = x * (64/ln(2)
+
+    # n = int( x * (64/log10of(2)) )
+    cvtpd2dq    %xmm3, %xmm4  #xmm4 = (int)n
+    cvtdq2pd    %xmm4, %xmm2  #xmm2 = (double)n
+
+    # r = x - n * ln(2)/64
+    # r *= ln(10)
+    mulsd       .L__real_log10of2_by_64(%rip),%xmm2 #xmm2 = n * log10of(2)/64
+    movd        %xmm4, %ecx     #ecx = n
+    subsd       %xmm2, %xmm0    #xmm0 = r
+    mulsd       .L__real_ln10(%rip),%xmm0 #xmm0 = r = r*ln10
+    movapd      %xmm0, %xmm1    #xmm1 = r
+
+    # q = r + r*r(1/2 + r*1/6)
+    movapd       .L__real_1_by_6(%rip), %xmm3 
+    mulsd       %xmm0, %xmm3 #xmm3 = 1/6 * r
+    mulsd       %xmm1, %xmm0 #xmm0 =  r  * r
+    addsd       .L__real_1_by_2(%rip), %xmm3 #xmm3 = 1/2 + (1/6 * r)
+    mulsd       %xmm3, %xmm0  #xmm0 = r*r*(1/2 + (1/6 * r))
+    addsd       %xmm1, %xmm0  #xmm0 = r+r*r*(1/2 + (1/6 * r))
+    
+    #j = n & 0x3f
+    mov         $0x3f, %rax     #rax = 0x3f
+    and         %ecx, %eax      #eax = j = n & 0x3f
+
+    # f + (f*q)
+    lea         L__two_to_jby64_table(%rip), %r10    
+    mulsd       (%r10,%rax,8), %xmm0
+    addsd       (%r10,%rax,8), %xmm0
+
+    .p2align 4
+    # m = (n - j) / 64        
+    psrad       $6,%xmm4
+    psllq       $52,%xmm4
+    paddq       %xmm0, %xmm4
+    cvtpd2ps    %xmm4, %xmm0
+    ret
+
+.p2align 4
+.L__y_is_zero:
+    pxor        %xmm1, %xmm1    #return value in xmm1,input in xmm0 before calling
+    mov         $2, %edi        #code in edi
+    #call        fname_special
+    pxor        %xmm0,%xmm0#remove this if calling fname special
+    ret         
+
+.p2align 4
+.L__y_is_inf:
+    mov         $0x7f800000,%edx
+    movd        %edx, %xmm1
+    mov         $3, %edi
+    #call        fname_special
+    movdqa     %xmm1,%xmm0#remove this if calling fname special
+    ret     
+
+.p2align 4
+.L__y_is_nan:
+    movaps %xmm0,%xmm1
+    addss  %xmm1,%xmm1
+    mov         $1, %edi
+    #call        fname_special
+    movdqa %xmm1,%xmm0  #remove this if calling fname special
+    ret       
+    
+.data
+.align 16
+.L__max_exp_arg:                 .long 0x421A209B
+.L__min_exp_arg:                 .long 0xC23369F4
+.L__real_64_by_log10of2:        .quad 0x406A934F0979A371 # 64/log10(2)
+.L__real_log10of2_by_64:        .quad 0x3F734413509F79FF # log10of2_by_64
+.L__real_ln10:                  .quad 0x40026BB1BBB55516 # ln(10)
+.L__real_1_by_6:                .quad 0x3fc5555555555555 # 1/6
+.L__real_1_by_2:                .quad 0x3fe0000000000000 # 1/2
+
+.align 16
+.type	L__two_to_jby64_table, @object
+.size	L__two_to_jby64_table, 512
+L__two_to_jby64_table:
+    .quad 0x3ff0000000000000
+    .quad 0x3ff02c9a3e778061
+    .quad 0x3ff059b0d3158574
+    .quad 0x3ff0874518759bc8
+    .quad 0x3ff0b5586cf9890f
+    .quad 0x3ff0e3ec32d3d1a2
+    .quad 0x3ff11301d0125b51
+    .quad 0x3ff1429aaea92de0
+    .quad 0x3ff172b83c7d517b
+    .quad 0x3ff1a35beb6fcb75
+    .quad 0x3ff1d4873168b9aa
+    .quad 0x3ff2063b88628cd6
+    .quad 0x3ff2387a6e756238
+    .quad 0x3ff26b4565e27cdd
+    .quad 0x3ff29e9df51fdee1
+    .quad 0x3ff2d285a6e4030b
+    .quad 0x3ff306fe0a31b715
+    .quad 0x3ff33c08b26416ff
+    .quad 0x3ff371a7373aa9cb
+    .quad 0x3ff3a7db34e59ff7
+    .quad 0x3ff3dea64c123422
+    .quad 0x3ff4160a21f72e2a
+    .quad 0x3ff44e086061892d
+    .quad 0x3ff486a2b5c13cd0
+    .quad 0x3ff4bfdad5362a27
+    .quad 0x3ff4f9b2769d2ca7
+    .quad 0x3ff5342b569d4f82
+    .quad 0x3ff56f4736b527da
+    .quad 0x3ff5ab07dd485429
+    .quad 0x3ff5e76f15ad2148
+    .quad 0x3ff6247eb03a5585
+    .quad 0x3ff6623882552225
+    .quad 0x3ff6a09e667f3bcd
+    .quad 0x3ff6dfb23c651a2f
+    .quad 0x3ff71f75e8ec5f74
+    .quad 0x3ff75feb564267c9
+    .quad 0x3ff7a11473eb0187
+    .quad 0x3ff7e2f336cf4e62
+    .quad 0x3ff82589994cce13
+    .quad 0x3ff868d99b4492ed
+    .quad 0x3ff8ace5422aa0db
+    .quad 0x3ff8f1ae99157736
+    .quad 0x3ff93737b0cdc5e5
+    .quad 0x3ff97d829fde4e50
+    .quad 0x3ff9c49182a3f090
+    .quad 0x3ffa0c667b5de565
+    .quad 0x3ffa5503b23e255d
+    .quad 0x3ffa9e6b5579fdbf
+    .quad 0x3ffae89f995ad3ad
+    .quad 0x3ffb33a2b84f15fb
+    .quad 0x3ffb7f76f2fb5e47
+    .quad 0x3ffbcc1e904bc1d2
+    .quad 0x3ffc199bdd85529c
+    .quad 0x3ffc67f12e57d14b
+    .quad 0x3ffcb720dcef9069
+    .quad 0x3ffd072d4a07897c
+    .quad 0x3ffd5818dcfba487
+    .quad 0x3ffda9e603db3285
+    .quad 0x3ffdfc97337b9b5f
+    .quad 0x3ffe502ee78b3ff6
+    .quad 0x3ffea4afa2a490da
+    .quad 0x3ffefa1bee615a27
+    .quad 0x3fff50765b6e4540
+    .quad 0x3fffa7c1819e90d8
+
+
diff --git a/src/gas/exp2.S b/src/gas/exp2.S
new file mode 100644
index 0000000..8e556d4
--- /dev/null
+++ b/src/gas/exp2.S
@@ -0,0 +1,355 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(exp2)
+#define fname_special _exp2_special@PLT
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.p2align 4
+.globl fname
+.type fname,@function
+fname:
+    ucomisd      .L__max_exp2_arg(%rip), %xmm0
+    ja           .L__y_is_inf
+    jp           .L__y_is_nan
+    ucomisd      .L__min_exp2_arg(%rip), %xmm0
+    jbe          .L__y_is_zero
+
+    # x * (64)
+    movapd      %xmm0,%xmm2        
+    mulsd       .L__real_64(%rip), %xmm2
+
+    # n = int( x * (64))
+    cvttpd2dq    %xmm2, %xmm1   #xmm1 = (int)n
+    cvtdq2pd    %xmm1, %xmm2   #xmm2 = (double)n
+    movd        %xmm1, %ecx
+
+    # r = x - n * 1/64  
+    #r *= ln2;      
+    mulsd    .L__one_by_64(%rip),%xmm2
+    addsd    %xmm0,%xmm2   #xmm2 = r    
+    mulsd    .L__ln_2(%rip),%xmm2    
+        
+    #j = n & 0x3f    
+    mov         $0x3f, %rax
+    and         %ecx, %eax     #eax = j
+    # m = (n - j) / 64      
+    sar         $6, %ecx       #ecx = m
+
+    # q = r + r^2*1/2 + r^3*1/6 + r^4 *1/24 + r^5*1/120 + r^6*1/720
+    # q = r + r*r*(1/2 + r*(1/6+ r*(1/24 + r*(1/120 + r*(1/720)))))
+    movapd       .L__real_1_by_720(%rip), %xmm3  #xmm3 = 1/720
+    mulsd       %xmm2, %xmm3    #xmm3 = r*1/720
+    movapd       .L__real_1_by_6(%rip), %xmm0    #xmm0 = 1/6    
+    movapd      %xmm2, %xmm1 #xmm1 = r            
+    mulsd       %xmm2, %xmm0    #xmm0 = r*1/6
+    addsd       .L__real_1_by_120(%rip), %xmm3  #xmm3 = 1/120 + (r*1/720)
+    mulsd       %xmm2, %xmm1    #xmm1 = r*r    
+    addsd       .L__real_1_by_2(%rip), %xmm0  #xmm0 = 1/2 + (r*1/6)        
+    movapd       %xmm1, %xmm4   #xmm4 = r*r
+    mulsd       %xmm1, %xmm4    #xmm4 = (r*r) * (r*r)    
+    mulsd       %xmm2, %xmm3    #xmm3 = r * (1/120 + (r*1/720))
+    mulsd       %xmm1, %xmm0    #xmm0 = (r*r)*(1/2 + (r*1/6))
+    addsd       .L__real_1_by_24(%rip), %xmm3  #xmm3 = 1/24 + (r * (1/120 + (r*1/720)))
+    addsd       %xmm2, %xmm0   #xmm0 = r + ((r*r)*(1/2 + (r*1/6)))
+    mulsd       %xmm4, %xmm3   #xmm3 = ((r*r) * (r*r)) * (1/24 + (r * (1/120 + (r*1/720))))
+    addsd       %xmm3, %xmm0   #xmm0 = r + ((r*r)*(1/2 + (r*1/6))) + ((r*r) * (r*r)) * (1/24 + (r * (1/120 + (r*1/720))))
+    
+    # (f)*(q) + f2 + f1
+    cmp         $0xfffffc02, %ecx # -1022    
+    lea         .L__two_to_jby64_table(%rip), %rdx        
+    lea         .L__two_to_jby64_tail_table(%rip), %r11       
+    lea         .L__two_to_jby64_head_table(%rip), %r10      
+    mulsd       (%rdx,%rax,8), %xmm0
+    addsd       (%r11,%rax,8), %xmm0
+    addsd       (%r10,%rax,8), %xmm0        
+
+    jle         .L__process_denormal 
+.L__process_normal:
+    shl         $52, %rcx    
+    movd        %rcx,%xmm2
+    paddq       %xmm2, %xmm0
+    ret
+
+.p2align 4
+.L__process_denormal:
+    jl          .L__process_true_denormal
+    ucomisd     .L__real_one(%rip), %xmm0
+    jae         .L__process_normal
+.L__process_true_denormal:
+    # here ( e^r < 1 and m = -1022 ) or m <= -1023
+    add         $1074, %ecx
+    mov         $1, %rax    
+    shl         %cl, %rax
+    movd         %rax, %xmm2
+    mulsd       %xmm2, %xmm0
+    ret        
+    
+.p2align 4
+.L__y_is_inf:
+    mov         $0x7ff0000000000000,%rax
+    movd       %rax, %xmm1
+    mov         $3, %edi
+    #call        fname_special
+    movdqa     %xmm1,%xmm0 #remove this if call is made    
+    ret     
+
+.p2align 4
+.L__y_is_nan:
+    movapd      %xmm0,%xmm1
+    addsd       %xmm0,%xmm1
+    mov         $1, %edi
+    #call        fname_special
+    movdqa     %xmm1,%xmm0 #remove this if call is made    
+    ret
+
+.p2align 4
+.L__y_is_zero:
+    pxor        %xmm1,%xmm1
+    mov         $2, %edi
+    #call        fname_special
+    movdqa     %xmm1,%xmm0 #remove this if call is made
+    ret      
+    
+.data
+.align 16
+.L__max_exp2_arg:            .quad 0x4090000000000000
+.L__min_exp2_arg:            .quad 0xc090c80000000000
+.L__real_64:                 .quad 0x4050000000000000    # 64
+.L__ln_2:                    .quad 0x3FE62E42FEFA39EF
+.L__one_by_64:               .quad 0xbF90000000000000
+
+.align 16
+.L__real_1_by_720:              .quad 0x3f56c16c16c16c17    # 1/720
+.L__real_1_by_120:              .quad 0x3f81111111111111    # 1/120
+.L__real_1_by_6:                .quad 0x3fc5555555555555    # 1/6
+.L__real_1_by_2:                .quad 0x3fe0000000000000    # 1/2
+.L__real_1_by_24:               .quad 0x3fa5555555555555    # 1/24
+.L__real_one:                   .quad 0x3ff0000000000000
+
+.align 16
+.L__two_to_jby64_table:
+    .quad 0x3ff0000000000000
+    .quad 0x3ff02c9a3e778061
+    .quad 0x3ff059b0d3158574
+    .quad 0x3ff0874518759bc8
+    .quad 0x3ff0b5586cf9890f
+    .quad 0x3ff0e3ec32d3d1a2
+    .quad 0x3ff11301d0125b51
+    .quad 0x3ff1429aaea92de0
+    .quad 0x3ff172b83c7d517b
+    .quad 0x3ff1a35beb6fcb75
+    .quad 0x3ff1d4873168b9aa
+    .quad 0x3ff2063b88628cd6
+    .quad 0x3ff2387a6e756238
+    .quad 0x3ff26b4565e27cdd
+    .quad 0x3ff29e9df51fdee1
+    .quad 0x3ff2d285a6e4030b
+    .quad 0x3ff306fe0a31b715
+    .quad 0x3ff33c08b26416ff
+    .quad 0x3ff371a7373aa9cb
+    .quad 0x3ff3a7db34e59ff7
+    .quad 0x3ff3dea64c123422
+    .quad 0x3ff4160a21f72e2a
+    .quad 0x3ff44e086061892d
+    .quad 0x3ff486a2b5c13cd0
+    .quad 0x3ff4bfdad5362a27
+    .quad 0x3ff4f9b2769d2ca7
+    .quad 0x3ff5342b569d4f82
+    .quad 0x3ff56f4736b527da
+    .quad 0x3ff5ab07dd485429
+    .quad 0x3ff5e76f15ad2148
+    .quad 0x3ff6247eb03a5585
+    .quad 0x3ff6623882552225
+    .quad 0x3ff6a09e667f3bcd
+    .quad 0x3ff6dfb23c651a2f
+    .quad 0x3ff71f75e8ec5f74
+    .quad 0x3ff75feb564267c9
+    .quad 0x3ff7a11473eb0187
+    .quad 0x3ff7e2f336cf4e62
+    .quad 0x3ff82589994cce13
+    .quad 0x3ff868d99b4492ed
+    .quad 0x3ff8ace5422aa0db
+    .quad 0x3ff8f1ae99157736
+    .quad 0x3ff93737b0cdc5e5
+    .quad 0x3ff97d829fde4e50
+    .quad 0x3ff9c49182a3f090
+    .quad 0x3ffa0c667b5de565
+    .quad 0x3ffa5503b23e255d
+    .quad 0x3ffa9e6b5579fdbf
+    .quad 0x3ffae89f995ad3ad
+    .quad 0x3ffb33a2b84f15fb
+    .quad 0x3ffb7f76f2fb5e47
+    .quad 0x3ffbcc1e904bc1d2
+    .quad 0x3ffc199bdd85529c
+    .quad 0x3ffc67f12e57d14b
+    .quad 0x3ffcb720dcef9069
+    .quad 0x3ffd072d4a07897c
+    .quad 0x3ffd5818dcfba487
+    .quad 0x3ffda9e603db3285
+    .quad 0x3ffdfc97337b9b5f
+    .quad 0x3ffe502ee78b3ff6
+    .quad 0x3ffea4afa2a490da
+    .quad 0x3ffefa1bee615a27
+    .quad 0x3fff50765b6e4540
+    .quad 0x3fffa7c1819e90d8
+
+.align 16
+.L__two_to_jby64_head_table:
+    .quad 0x3ff0000000000000
+    .quad 0x3ff02c9a30000000
+    .quad 0x3ff059b0d0000000
+    .quad 0x3ff0874510000000
+    .quad 0x3ff0b55860000000
+    .quad 0x3ff0e3ec30000000
+    .quad 0x3ff11301d0000000
+    .quad 0x3ff1429aa0000000
+    .quad 0x3ff172b830000000
+    .quad 0x3ff1a35be0000000
+    .quad 0x3ff1d48730000000
+    .quad 0x3ff2063b80000000
+    .quad 0x3ff2387a60000000
+    .quad 0x3ff26b4560000000
+    .quad 0x3ff29e9df0000000
+    .quad 0x3ff2d285a0000000
+    .quad 0x3ff306fe00000000
+    .quad 0x3ff33c08b0000000
+    .quad 0x3ff371a730000000
+    .quad 0x3ff3a7db30000000
+    .quad 0x3ff3dea640000000
+    .quad 0x3ff4160a20000000
+    .quad 0x3ff44e0860000000
+    .quad 0x3ff486a2b0000000
+    .quad 0x3ff4bfdad0000000
+    .quad 0x3ff4f9b270000000
+    .quad 0x3ff5342b50000000
+    .quad 0x3ff56f4730000000
+    .quad 0x3ff5ab07d0000000
+    .quad 0x3ff5e76f10000000
+    .quad 0x3ff6247eb0000000
+    .quad 0x3ff6623880000000
+    .quad 0x3ff6a09e60000000
+    .quad 0x3ff6dfb230000000
+    .quad 0x3ff71f75e0000000
+    .quad 0x3ff75feb50000000
+    .quad 0x3ff7a11470000000
+    .quad 0x3ff7e2f330000000
+    .quad 0x3ff8258990000000
+    .quad 0x3ff868d990000000
+    .quad 0x3ff8ace540000000
+    .quad 0x3ff8f1ae90000000
+    .quad 0x3ff93737b0000000
+    .quad 0x3ff97d8290000000
+    .quad 0x3ff9c49180000000
+    .quad 0x3ffa0c6670000000
+    .quad 0x3ffa5503b0000000
+    .quad 0x3ffa9e6b50000000
+    .quad 0x3ffae89f90000000
+    .quad 0x3ffb33a2b0000000
+    .quad 0x3ffb7f76f0000000
+    .quad 0x3ffbcc1e90000000
+    .quad 0x3ffc199bd0000000
+    .quad 0x3ffc67f120000000
+    .quad 0x3ffcb720d0000000
+    .quad 0x3ffd072d40000000
+    .quad 0x3ffd5818d0000000
+    .quad 0x3ffda9e600000000
+    .quad 0x3ffdfc9730000000
+    .quad 0x3ffe502ee0000000
+    .quad 0x3ffea4afa0000000
+    .quad 0x3ffefa1be0000000
+    .quad 0x3fff507650000000
+    .quad 0x3fffa7c180000000
+
+.align 16
+.L__two_to_jby64_tail_table:
+    .quad 0x0000000000000000
+    .quad 0x3e6cef00c1dcdef9
+    .quad 0x3e48ac2ba1d73e2a
+    .quad 0x3e60eb37901186be
+    .quad 0x3e69f3121ec53172
+    .quad 0x3e469e8d10103a17
+    .quad 0x3df25b50a4ebbf1a
+    .quad 0x3e6d525bbf668203
+    .quad 0x3e68faa2f5b9bef9
+    .quad 0x3e66df96ea796d31
+    .quad 0x3e368b9aa7805b80
+    .quad 0x3e60c519ac771dd6
+    .quad 0x3e6ceac470cd83f5
+    .quad 0x3e5789f37495e99c
+    .quad 0x3e547f7b84b09745
+    .quad 0x3e5b900c2d002475
+    .quad 0x3e64636e2a5bd1ab
+    .quad 0x3e4320b7fa64e430
+    .quad 0x3e5ceaa72a9c5154
+    .quad 0x3e53967fdba86f24
+    .quad 0x3e682468446b6824
+    .quad 0x3e3f72e29f84325b
+    .quad 0x3e18624b40c4dbd0
+    .quad 0x3e5704f3404f068e
+    .quad 0x3e54d8a89c750e5e
+    .quad 0x3e5a74b29ab4cf62
+    .quad 0x3e5a753e077c2a0f
+    .quad 0x3e5ad49f699bb2c0
+    .quad 0x3e6a90a852b19260
+    .quad 0x3e56b48521ba6f93
+    .quad 0x3e0d2ac258f87d03
+    .quad 0x3e42a91124893ecf
+    .quad 0x3e59fcef32422cbe
+    .quad 0x3e68ca345de441c5
+    .quad 0x3e61d8bee7ba46e1
+    .quad 0x3e59099f22fdba6a
+    .quad 0x3e4f580c36bea881
+    .quad 0x3e5b3d398841740a
+    .quad 0x3e62999c25159f11
+    .quad 0x3e668925d901c83b
+    .quad 0x3e415506dadd3e2a
+    .quad 0x3e622aee6c57304e
+    .quad 0x3e29b8bc9e8a0387
+    .quad 0x3e6fbc9c9f173d24
+    .quad 0x3e451f8480e3e235
+    .quad 0x3e66bbcac96535b5
+    .quad 0x3e41f12ae45a1224
+    .quad 0x3e55e7f6fd0fac90
+    .quad 0x3e62b5a75abd0e69
+    .quad 0x3e609e2bf5ed7fa1
+    .quad 0x3e47daf237553d84
+    .quad 0x3e12f074891ee83d
+    .quad 0x3e6b0aa538444196
+    .quad 0x3e6cafa29694426f
+    .quad 0x3e69df20d22a0797
+    .quad 0x3e640f12f71a1e45
+    .quad 0x3e69f7490e4bb40b
+    .quad 0x3e4ed9942b84600d
+    .quad 0x3e4bdcdaf5cb4656
+    .quad 0x3e5e2cffd89cf44c
+    .quad 0x3e452486cc2c7b9d
+    .quad 0x3e6cc2b44eee3fa4
+    .quad 0x3e66dc8a80ce9f09
+    .quad 0x3e39e90d82e90a7e
+
+
diff --git a/src/gas/exp2f.S b/src/gas/exp2f.S
new file mode 100644
index 0000000..78c50e0
--- /dev/null
+++ b/src/gas/exp2f.S
@@ -0,0 +1,193 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(exp2f)
+#define fname_special _exp2f_special@PLT
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.p2align 4
+.globl fname
+.type fname,@function
+fname:
+    ucomiss .L__max_exp2_arg(%rip), %xmm0
+    ja .L__y_is_inf
+    jp .L__y_is_nan
+    ucomiss .L__min_exp2_arg(%rip), %xmm0
+    jb .L__y_is_zero
+
+    cvtps2pd     %xmm0, %xmm0    #xmm0 = (double)x
+
+    # x * (64)
+    movapd      %xmm0,%xmm3      #xmm3 = (double)x
+    #mulsd       .L__sixtyfour(%rip), %xmm3  #xmm3 = x * (64)
+    paddq       .L__sixtyfour(%rip), %xmm3  #xmm3 = x * (64)
+
+    # n = int( x * (64)
+    cvtpd2dq    %xmm3, %xmm4  #xmm4 = (int)n
+    cvtdq2pd    %xmm4, %xmm2  #xmm2 = (double)n
+
+    # r = x - n * 1/64
+    # r *= ln(2)
+    mulsd       .L__one_by_64(%rip),%xmm2 #xmm2 = n * 1/64
+    movd        %xmm4, %ecx     #ecx = n
+    subsd       %xmm2, %xmm0    #xmm0 = r
+    mulsd       .L__ln2(%rip),%xmm0 #xmm0 = r = r*ln(2)    
+    movapd      %xmm0, %xmm1    #xmm1 = r
+
+    # q
+    movsd       .L__real_1_by_6(%rip), %xmm3 
+    mulsd       %xmm0, %xmm3 #xmm3 = 1/6 * r
+    mulsd       %xmm1, %xmm0 #xmm0 =  r  * r
+    addsd       .L__real_1_by_2(%rip), %xmm3 #xmm3 = 1/2 + (1/6 * r)
+    mulsd       %xmm3, %xmm0  #xmm0 = r*r*(1/2 + (1/6 * r))
+    addsd       %xmm1, %xmm0  #xmm0 = r+r*r*(1/2 + (1/6 * r))
+    
+    #j = n & 0x3f
+    mov         $0x3f, %rax     #rax = 0x3f
+    and         %ecx, %eax      #eax = j = n & 0x3f
+
+    # f + (f*q)
+    lea         L__two_to_jby64_table(%rip), %r10    
+    mulsd       (%r10,%rax,8), %xmm0
+    addsd       (%r10,%rax,8), %xmm0
+
+    .p2align 4
+    # m = (n - j) / 64        
+    psrad       $6,%xmm4
+    psllq       $52,%xmm4
+    paddq       %xmm0, %xmm4
+    cvtpd2ps    %xmm4, %xmm0
+    ret
+
+.p2align 4
+.L__y_is_zero:
+    pxor        %xmm1, %xmm1    #return value in xmm1,input in xmm0 before calling
+    mov         $2, %edi        #code in edi
+    #call        fname_special
+    pxor        %xmm0,%xmm0#remove this if calling fname special
+    ret         
+
+.p2align 4
+.L__y_is_inf:
+    mov         $0x7f800000,%edx
+    movd        %edx, %xmm1
+    mov         $3, %edi
+    #call        fname_special
+    movdqa     %xmm1,%xmm0#remove this if calling fname special
+    ret     
+
+.p2align 4
+.L__y_is_nan:
+    movaps %xmm0,%xmm1
+    addss  %xmm1,%xmm1
+    mov         $1, %edi
+    #call        fname_special
+    movdqa %xmm1,%xmm0  #remove this if calling fname special
+    ret      
+    
+.data
+.align 16
+.L__max_exp2_arg:                 .long 0x43000000
+.L__min_exp2_arg:                 .long 0xc3150000
+.align 16
+.L__sixtyfour:                  .quad 0x0060000000000000 # 64
+.L__one_by_64:                  .quad 0x3F90000000000000 # 1/64
+.L__ln2:                        .quad 0x3FE62E42FEFA39EF # ln(2)
+.L__real_1_by_6:                .quad 0x3fc5555555555555 # 1/6
+.L__real_1_by_2:                .quad 0x3fe0000000000000 # 1/2
+
+.align 16
+.type	L__two_to_jby64_table, @object
+.size	L__two_to_jby64_table, 512
+L__two_to_jby64_table:
+    .quad 0x3ff0000000000000
+    .quad 0x3ff02c9a3e778061
+    .quad 0x3ff059b0d3158574
+    .quad 0x3ff0874518759bc8
+    .quad 0x3ff0b5586cf9890f
+    .quad 0x3ff0e3ec32d3d1a2
+    .quad 0x3ff11301d0125b51
+    .quad 0x3ff1429aaea92de0
+    .quad 0x3ff172b83c7d517b
+    .quad 0x3ff1a35beb6fcb75
+    .quad 0x3ff1d4873168b9aa
+    .quad 0x3ff2063b88628cd6
+    .quad 0x3ff2387a6e756238
+    .quad 0x3ff26b4565e27cdd
+    .quad 0x3ff29e9df51fdee1
+    .quad 0x3ff2d285a6e4030b
+    .quad 0x3ff306fe0a31b715
+    .quad 0x3ff33c08b26416ff
+    .quad 0x3ff371a7373aa9cb
+    .quad 0x3ff3a7db34e59ff7
+    .quad 0x3ff3dea64c123422
+    .quad 0x3ff4160a21f72e2a
+    .quad 0x3ff44e086061892d
+    .quad 0x3ff486a2b5c13cd0
+    .quad 0x3ff4bfdad5362a27
+    .quad 0x3ff4f9b2769d2ca7
+    .quad 0x3ff5342b569d4f82
+    .quad 0x3ff56f4736b527da
+    .quad 0x3ff5ab07dd485429
+    .quad 0x3ff5e76f15ad2148
+    .quad 0x3ff6247eb03a5585
+    .quad 0x3ff6623882552225
+    .quad 0x3ff6a09e667f3bcd
+    .quad 0x3ff6dfb23c651a2f
+    .quad 0x3ff71f75e8ec5f74
+    .quad 0x3ff75feb564267c9
+    .quad 0x3ff7a11473eb0187
+    .quad 0x3ff7e2f336cf4e62
+    .quad 0x3ff82589994cce13
+    .quad 0x3ff868d99b4492ed
+    .quad 0x3ff8ace5422aa0db
+    .quad 0x3ff8f1ae99157736
+    .quad 0x3ff93737b0cdc5e5
+    .quad 0x3ff97d829fde4e50
+    .quad 0x3ff9c49182a3f090
+    .quad 0x3ffa0c667b5de565
+    .quad 0x3ffa5503b23e255d
+    .quad 0x3ffa9e6b5579fdbf
+    .quad 0x3ffae89f995ad3ad
+    .quad 0x3ffb33a2b84f15fb
+    .quad 0x3ffb7f76f2fb5e47
+    .quad 0x3ffbcc1e904bc1d2
+    .quad 0x3ffc199bdd85529c
+    .quad 0x3ffc67f12e57d14b
+    .quad 0x3ffcb720dcef9069
+    .quad 0x3ffd072d4a07897c
+    .quad 0x3ffd5818dcfba487
+    .quad 0x3ffda9e603db3285
+    .quad 0x3ffdfc97337b9b5f
+    .quad 0x3ffe502ee78b3ff6
+    .quad 0x3ffea4afa2a490da
+    .quad 0x3ffefa1bee615a27
+    .quad 0x3fff50765b6e4540
+    .quad 0x3fffa7c1819e90d8
+
+
diff --git a/src/gas/expf.S b/src/gas/expf.S
new file mode 100644
index 0000000..cefa608
--- /dev/null
+++ b/src/gas/expf.S
@@ -0,0 +1,201 @@
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+#ifdef __x86_64__
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#
+# expf.S
+#
+# An implementation of the expf libm function.
+#
+# Prototype:
+#
+#     float expf(float x);
+#
+
+#
+#   Algorithm:
+#       Similar to one presnted in exp.S
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(expf)
+#define fname_special _expf_special@PLT
+
+.text
+.p2align 4
+.globl fname
+.type fname,@function
+fname:
+    ucomiss .L__max_exp_arg(%rip), %xmm0
+    ja .L__y_is_inf
+    jp .L__y_is_nan
+    ucomiss .L__min_exp_arg(%rip), %xmm0
+    jb .L__y_is_zero
+
+    cvtps2pd     %xmm0, %xmm0    #xmm0 = (double)x
+
+    # x * (64/ln(2))
+    movapd      %xmm0,%xmm3      #xmm3 = (xouble)x
+    mulsd       .L__real_64_by_log2(%rip), %xmm3  #xmm3 = x * (64/ln(2)
+
+    # n = int( x * (64/ln(2)) )
+    cvtpd2dq    %xmm3, %xmm4  #xmm4 = (int)n
+    cvtdq2pd    %xmm4, %xmm2  #xmm2 = (double)n
+
+    # r = x - n * ln(2)/64
+    mulsd       .L__real_log2_by_64(%rip),%xmm2 #xmm2 = n * ln(2)/64
+    movd        %xmm4, %ecx     #ecx = n
+    subsd       %xmm2, %xmm0    #xmm0 = r
+    movapd      %xmm0, %xmm1    #xmm1 = r
+
+    # q
+    movsd       .L__real_1_by_6(%rip), %xmm3 
+    mulsd       %xmm0, %xmm3 #xmm3 = 1/6 * r
+    mulsd       %xmm1, %xmm0 #xmm0 =  r  * r
+    addsd       .L__real_1_by_2(%rip), %xmm3 #xmm3 = 1/2 + (1/6 * r)
+    mulsd       %xmm3, %xmm0  #xmm0 = r*r*(1/2 + (1/6 * r))
+    addsd       %xmm1, %xmm0  #xmm0 = r+r*r*(1/2 + (1/6 * r))
+    
+    #j = n & 0x3f
+    mov         $0x3f, %rax     #rax = 0x3f
+    and         %ecx, %eax      #eax = j = n & 0x3f
+    # m = (n - j) / 64    
+    sar         $6, %ecx        #ecx = m
+    shl         $52, %rcx
+
+    # (f)*(1+q)
+    lea         L__two_to_jby64_table(%rip), %r10    
+    movsd       (%r10,%rax,8), %xmm2
+    mulsd       %xmm2, %xmm0
+    addsd       %xmm2, %xmm0
+
+    movd        %rcx, %xmm1
+    paddq       %xmm0, %xmm1
+    cvtpd2ps    %xmm1, %xmm0
+    ret
+
+.p2align 4
+.L__y_is_zero:
+
+    pxor        %xmm1, %xmm1    #return value in xmm1,input in xmm0 before calling
+    mov         $2, %edi        #code in edi
+    jmp         fname_special
+
+.p2align 4
+.L__y_is_inf:
+
+    mov         $0x7f800000,%edx
+    movd        %edx, %xmm1
+    mov         $3, %edi
+    jmp         fname_special
+
+.p2align 4
+.L__y_is_nan:
+    movaps %xmm0,%xmm1
+    addss  %xmm1,%xmm1
+    mov         $1, %edi
+    jmp         fname_special
+    
+.data
+.align 16
+.L__max_exp_arg:                 .long 0x42B17218
+.L__min_exp_arg:                 .long 0xC2CE8ED0
+.L__real_64_by_log2:            .quad 0x40571547652b82fe # 64/ln(2)
+.L__real_log2_by_64:            .quad 0x3f862e42fefa39ef # log2_by_64
+.L__real_1_by_6:                .quad 0x3fc5555555555555 # 1/6
+.L__real_1_by_2:                .quad 0x3fe0000000000000 # 1/2
+
+.align 16
+.type	L__two_to_jby64_table, @object
+.size	L__two_to_jby64_table, 512
+L__two_to_jby64_table:
+    .quad 0x3ff0000000000000
+    .quad 0x3ff02c9a3e778061
+    .quad 0x3ff059b0d3158574
+    .quad 0x3ff0874518759bc8
+    .quad 0x3ff0b5586cf9890f
+    .quad 0x3ff0e3ec32d3d1a2
+    .quad 0x3ff11301d0125b51
+    .quad 0x3ff1429aaea92de0
+    .quad 0x3ff172b83c7d517b
+    .quad 0x3ff1a35beb6fcb75
+    .quad 0x3ff1d4873168b9aa
+    .quad 0x3ff2063b88628cd6
+    .quad 0x3ff2387a6e756238
+    .quad 0x3ff26b4565e27cdd
+    .quad 0x3ff29e9df51fdee1
+    .quad 0x3ff2d285a6e4030b
+    .quad 0x3ff306fe0a31b715
+    .quad 0x3ff33c08b26416ff
+    .quad 0x3ff371a7373aa9cb
+    .quad 0x3ff3a7db34e59ff7
+    .quad 0x3ff3dea64c123422
+    .quad 0x3ff4160a21f72e2a
+    .quad 0x3ff44e086061892d
+    .quad 0x3ff486a2b5c13cd0
+    .quad 0x3ff4bfdad5362a27
+    .quad 0x3ff4f9b2769d2ca7
+    .quad 0x3ff5342b569d4f82
+    .quad 0x3ff56f4736b527da
+    .quad 0x3ff5ab07dd485429
+    .quad 0x3ff5e76f15ad2148
+    .quad 0x3ff6247eb03a5585
+    .quad 0x3ff6623882552225
+    .quad 0x3ff6a09e667f3bcd
+    .quad 0x3ff6dfb23c651a2f
+    .quad 0x3ff71f75e8ec5f74
+    .quad 0x3ff75feb564267c9
+    .quad 0x3ff7a11473eb0187
+    .quad 0x3ff7e2f336cf4e62
+    .quad 0x3ff82589994cce13
+    .quad 0x3ff868d99b4492ed
+    .quad 0x3ff8ace5422aa0db
+    .quad 0x3ff8f1ae99157736
+    .quad 0x3ff93737b0cdc5e5
+    .quad 0x3ff97d829fde4e50
+    .quad 0x3ff9c49182a3f090
+    .quad 0x3ffa0c667b5de565
+    .quad 0x3ffa5503b23e255d
+    .quad 0x3ffa9e6b5579fdbf
+    .quad 0x3ffae89f995ad3ad
+    .quad 0x3ffb33a2b84f15fb
+    .quad 0x3ffb7f76f2fb5e47
+    .quad 0x3ffbcc1e904bc1d2
+    .quad 0x3ffc199bdd85529c
+    .quad 0x3ffc67f12e57d14b
+    .quad 0x3ffcb720dcef9069
+    .quad 0x3ffd072d4a07897c
+    .quad 0x3ffd5818dcfba487
+    .quad 0x3ffda9e603db3285
+    .quad 0x3ffdfc97337b9b5f
+    .quad 0x3ffe502ee78b3ff6
+    .quad 0x3ffea4afa2a490da
+    .quad 0x3ffefa1bee615a27
+    .quad 0x3fff50765b6e4540
+    .quad 0x3fffa7c1819e90d8
+
+
+#endif
diff --git a/src/gas/expm1.S b/src/gas/expm1.S
new file mode 100644
index 0000000..dff043c
--- /dev/null
+++ b/src/gas/expm1.S
@@ -0,0 +1,359 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(expm1)
+
+#ifdef __ELF__
+    .section .note.GNU-stack,"",@progbits
+#endif
+
+	.text
+	.p2align 4
+.globl fname
+	.type	fname, @function
+		
+fname:
+
+    ucomisd .L__max_expm1_arg(%rip),%xmm0  #check if(x > 709.8)
+    ja .L__Max_Arg
+    jp .L__Max_Arg
+    ucomisd .L__min_expm1_arg(%rip),%xmm0  #if(x < -37.42994775023704)
+    jb .L__Min_Arg
+    ucomisd .L__log_OneMinus_OneByFour(%rip),%xmm0
+    jbe .L__Normal_Flow
+    ucomisd .L__log_OnePlus_OneByFour(%rip),%xmm0
+    jb .L__Small_Arg 
+    
+    .p2align 4
+.L__Normal_Flow:
+    movapd %xmm0,%xmm1  #xmm1 = x
+    mulsd .L__thirtyTwo_by_ln2(%rip),%xmm1   #xmm1 = x*thirtyTwo_by_ln2
+    ucomisd .L__zero(%rip),%xmm1             #check if temp < 0.0
+    jae .L__Add_Point_Five
+    subsd .L__point_Five(%rip),%xmm1
+    jmp .L__next     
+.L__Add_Point_Five:
+    addsd .L__point_Five(%rip),%xmm1         #xmm1 = temp +/- 0.5
+.L__next:
+    cvttpd2dq %xmm1,%xmm2              #xmm2 = (int)n
+    cvtdq2pd  %xmm2,%xmm1              #xmm1 = (double)n  
+    movapd %xmm2,%xmm3                 #xmm3 = (int)n
+    psrad $5,%xmm2                     #xmm2 = m
+    pslld $27,%xmm3            
+    psrld $27,%xmm3                    #xmm3 = j    
+    movd %xmm3,%edx                    #edx = j
+    movd %xmm2,%ecx                    #ecx = m
+    
+    movlhps %xmm1,%xmm1                #xmm1 = n,n
+    mulpd .L__Ln2By32_MinusTrailLead(%rip),%xmm1 
+    movapd %xmm0,%xmm2
+    subsd %xmm1,%xmm2                  #xmm2 = r1
+    psrldq $8,%xmm1                    #xmm1 = r2
+    movapd %xmm2,%xmm3                 #xmm3 = r1    
+    addsd %xmm1,%xmm3                  #xmm3 = r
+    #q = r*(r*(A1.f64 + r*(A2.f64 + r*(A3.f64 + r*(A4.f64 + r*(A5.f64))))));    
+    movapd %xmm3,%xmm4
+    mulsd .L__A5(%rip),%xmm4
+    addsd .L__A4(%rip),%xmm4
+    mulsd %xmm3,%xmm4
+    addsd .L__A3(%rip),%xmm4
+    mulsd %xmm3,%xmm4
+    addsd .L__A2(%rip),%xmm4
+    mulsd %xmm3,%xmm4
+    addsd .L__A1(%rip),%xmm4
+    mulsd %xmm3,%xmm4
+    mulsd %xmm4,%xmm3                #xmm3 = q
+    
+    shl $4,%edx
+	lea  S_lead_and_trail_table(%rip),%rax
+    movdqa  (%rax,%rdx,1),%xmm5       #xmm5 = S_T,S_L
+    
+    #p = (r2+q) + r1;
+    addsd %xmm3,%xmm1
+    addsd %xmm1,%xmm2                #xmm2 = p
+    
+    #s = S_L.f64 + S_T.f64;    
+    movhlps %xmm5,%xmm4              #xmm4 = S_T
+    movapd %xmm4,%xmm3               #xmm3 = S_T
+    addsd %xmm5,%xmm3                #xmm3 = s
+    
+    cmp $52,%ecx        #check m > 52
+    jg .L__M_Above_52
+    cmp $-7,%ecx        #check if m < -7
+    jl .L__M_Below_Minus7
+    #(-8 < m) && (m < 53)
+    movapd %xmm2,%xmm3               #xmm3 = p
+    addsd .L__One(%rip),%xmm3  #xmm3 = 1+p
+    mulsd %xmm4,%xmm3          #xmm3 = S_T.f64 *(1+p)
+    mulsd %xmm5,%xmm2                #xmm2 = S_L*p
+    addsd %xmm3,%xmm2 #xmm2 = (S_L.f64*p+ S_T.f64 *(1+p))
+    mov $1023,%edx
+    sub %ecx,%edx                    #edx = twopmm
+    shl $52,%rdx
+    movd %rdx,%xmm1            #xmm1 = twopmm
+    subsd %xmm1,%xmm5    #xmm5 = S_L.f64 - twopmm.f64
+    addsd %xmm5,%xmm2
+    shl $52,%rcx
+    movd %rcx,%xmm0      #xmm0 = twopm
+    paddq %xmm2,%xmm0   #xmm0 = twopm *(xmm2)
+    ret   
+    
+    .p2align 4  
+.L__M_Above_52:
+    cmp $1024,%ecx #check if m = 1024
+    je .L__M_Equals_1024
+    #twopm.f64 * (S_L.f64 + (s*p+(S_T.f64 - twopmm.f64)));// 2^-m should not be calculated if m>105
+    mov $1023,%edx
+    sub %ecx,%edx                    #edx = twopmm
+    shl $52,%rdx
+    movd %rdx,%xmm1            #xmm1 = twopmm
+    subsd %xmm1,%xmm4  #xmm4 = S_T - twopmm
+    mulsd %xmm3,%xmm2  #xmm2 = s*p
+    addsd %xmm4,%xmm2 
+    addsd %xmm5,%xmm2
+    shl $52,%rcx
+    movd %rcx,%xmm0      #xmm0 = twopm
+    paddq %xmm2,%xmm0
+    ret
+    
+    .p2align 4    
+.L__M_Below_Minus7:
+    #twopm.f64 * (S_L.f64 + (s*p + S_T.f64)) - 1;
+    mulsd %xmm3,%xmm2    #xmm2 = s*p
+    addsd %xmm4,%xmm2   #xmm2 = (s*p + S_T.f64)
+    addsd %xmm5,%xmm2   #xmm2 = (S_L.f64 + (s*p + S_T.f64))
+    shl $52,%rcx
+    movd %rcx,%xmm0      #xmm0 = twopm
+    paddq %xmm2,%xmm0   #xmm0 = twopm *(xmm2)
+    subsd .L__One(%rip),%xmm0    
+    ret
+    
+    .p2align 4
+.L__M_Equals_1024:
+    mov $0x4000000000000000,%rax #1024 at exponent
+    mulsd %xmm3,%xmm2 #xmm2 = s*p
+    addsd %xmm4,%xmm2 #xmm2 = (s*p) + S_T
+    addsd %xmm5,%xmm2 #xmm2 = S_L + ((s*p) + S_T)
+    movd %rax,%xmm1 #xmm1 = twopm
+    paddq %xmm2,%xmm1
+    movd %xmm1,%rax
+    mov $0x7FF0000000000000,%rcx
+    and %rcx,%rax
+    cmp %rcx,%rax #check if we reached inf
+    je .L__return_Inf
+    movapd %xmm1,%xmm0                   
+    ret
+    
+    .p2align 4
+.L__Small_Arg:
+    movapd %xmm0,%xmm1
+    psllq $1,%xmm1
+    psrlq $1,%xmm1            #xmm1 = abs(x)
+    ucomisd .L__Five_Pont_FiveEMinus17(%rip),%xmm1
+    jb .L__VeryTinyArg
+    mov $0x01E0000000000000,%rax #30 in exponents place
+    #u = (twop30.f64 * x + x) - twop30.f64 * x;    
+    movd %rax,%xmm1
+    paddq %xmm0,%xmm1  #xmm1 = twop30.f64 * x
+    movapd %xmm1,%xmm2
+    addsd %xmm0,%xmm2 #xmm2 = (twop30.f64 * x + x)
+    subsd %xmm1,%xmm2 #xmm2 = u
+    movapd %xmm0,%xmm1
+    subsd %xmm2,%xmm1 #xmm1 = v = x-u
+    movapd %xmm2,%xmm3 #xmm3 = u
+    mulsd %xmm2,%xmm3 #xmm3 = u*u
+    mulsd .L__point_Five(%rip),%xmm3 #xmm3 = y = u*u*0.5
+    #z = v * (x + u) * 0.5;
+    movapd %xmm0,%xmm4
+    addsd %xmm2,%xmm4
+    mulsd %xmm1,%xmm4
+    mulsd .L__point_Five(%rip),%xmm4 #xmm4 = z   
+    
+    #q = x*x*x*(A1.f64 + x*(A2.f64 + x*(A3.f64 + x*(A4.f64 + x*(A5.f64 + x*(A6.f64 + x*(A7.f64 + x*(A8.f64 + x*(A9.f64)))))))));
+    movapd %xmm0,%xmm5
+    mulsd .L__B9(%rip),%xmm5
+    addsd .L__B8(%rip),%xmm5
+    mulsd %xmm0,%xmm5
+    addsd .L__B7(%rip),%xmm5
+    mulsd %xmm0,%xmm5
+    addsd .L__B6(%rip),%xmm5
+    mulsd %xmm0,%xmm5           
+    addsd .L__B5(%rip),%xmm5
+    mulsd %xmm0,%xmm5    
+    addsd .L__B4(%rip),%xmm5
+    mulsd %xmm0,%xmm5    
+    addsd .L__B3(%rip),%xmm5
+    mulsd %xmm0,%xmm5    
+    addsd .L__B2(%rip),%xmm5
+    mulsd %xmm0,%xmm5   
+    addsd .L__B1(%rip),%xmm5
+    mulsd %xmm0,%xmm5  
+    mulsd %xmm0,%xmm5  
+    mulsd %xmm0,%xmm5   #xmm5 = q
+    
+    ucomisd .L__TwopM7(%rip),%xmm3    
+    jb .L__returnNext
+    addsd %xmm4,%xmm1  #xmm1 = v+z
+    addsd %xmm5,%xmm1  #xmm1 = q+(v+z)
+    addsd %xmm3,%xmm2  #xmm2 = u+y
+    addsd %xmm2,%xmm1
+    movapd %xmm1,%xmm0
+    ret    
+    .p2align 4
+.L__returnNext:
+    addsd %xmm5,%xmm4  #xmm4 = q +z
+    addsd %xmm4,%xmm3  #xmm3 = y+(q+z)
+    addsd %xmm3,%xmm0    
+    ret
+    
+    .p2align 4  
+.L__VeryTinyArg:
+    #(twop100.f64 * x + xabs.f64) * twopm100.f64);
+    mov $0x0640000000000000,%rax #100 at exponent's place
+    movd %rax,%xmm2
+    paddq %xmm2,%xmm0
+    addsd %xmm1,%xmm0
+    psubq %xmm2,%xmm0
+    ret    
+      
+    
+    .p2align 4
+.L__Max_Arg:
+   movd %xmm0,%rcx
+   mov $0x7ff0000000000000,%rax
+   cmp %rax,%rcx                        #x is either Nan or Inf
+   jb .L__return_Inf
+   mov $0x000fffffffffffff,%rdx         #check if x is Nan
+   and %rdx,%rcx
+   jne .L__Nan
+.L__return_Inf:
+   movd %rax,%xmm0
+   #call error_handler  
+   ret
+   .p2align 4 
+.L__Nan:
+    addsd   %xmm0,%xmm0
+    ret      
+   ret
+    
+    .p2align 4  
+.L__Min_Arg:
+    mov $0xBFF0000000000000,%rax   #return -1
+    #call error handler
+    movd %rax,%xmm0
+    ret      
+    
+.data
+.align 16
+.L__max_expm1_arg:
+    .quad 0x40862E6666666666    
+.L__min_expm1_arg:
+    .quad 0xC042B708872320E1
+.L__log_OneMinus_OneByFour:
+    .quad 0xBFD269621134DB93
+.L__log_OnePlus_OneByFour:
+    .quad 0x3FCC8FF7C79A9A22
+.L__thirtyTwo_by_ln2:    
+    .quad 0x40471547652B82FE
+.L__zero:
+    .quad 0x0000000000000000    
+.L__point_Five:
+    .quad 0x3FE0000000000000
+    
+.align 16    
+.L__Ln2By32_MinusTrailLead:
+    .octa 0xBD8473DE6AF278ED3F962E42FEF00000 
+.L__A5:
+    .quad 0x3F56C1728D739765
+.L__A4:
+    .quad 0x3F811115B7AA905E
+.L__A3:
+    .quad 0x3FA5555555545D4E
+.L__A2:
+    .quad 0x3FC5555555548F7C
+.L__A1:
+    .quad 0x3FE0000000000000      
+.L__One:
+    .quad 0x3FF0000000000000
+
+.align 16
+# .type	two_to_jby32_table, @object
+# .size	two_to_jby32_table, 512
+S_lead_and_trail_table:
+	.octa  0x00000000000000003FF0000000000000
+	.octa  0x3D0A1D73E2A475B43FF059B0D3158540
+	.octa  0x3CEEC5317256E3083FF0B5586CF98900
+	.octa  0x3CF0A4EBBF1AED933FF11301D0125B40
+	.octa  0x3D0D6E6FBE4628763FF172B83C7D5140
+	.octa  0x3D053C02DC0144C83FF1D4873168B980
+	.octa  0x3D0C3360FD6D8E0B3FF2387A6E756200
+	.octa  0x3D009612E8AFAD123FF29E9DF51FDEC0
+	.octa  0x3CF52DE8D5A463063FF306FE0A31B700
+	.octa  0x3CE54E28AA05E8A93FF371A7373AA9C0
+	.octa  0x3D011ADA0911F09F3FF3DEA64C123400
+	.octa  0x3D068189B7A04EF83FF44E0860618900
+	.octa  0x3D038EA1CBD7F6213FF4BFDAD5362A00
+	.octa  0x3CBDF0A83C49D86A3FF5342B569D4F80
+	.octa  0x3D04AC64980A8C8F3FF5AB07DD485400
+	.octa  0x3CD2C7C3E81BF4B73FF6247EB03A5580
+	.octa  0x3CE921165F626CDD3FF6A09E667F3BC0
+	.octa  0x3D09EE91B87977853FF71F75E8EC5F40
+	.octa  0x3CDB5F54408FDB373FF7A11473EB0180
+	.octa  0x3CF28ACF88AFAB353FF82589994CCE00
+	.octa  0x3CFB5BA7C55A192D3FF8ACE5422AA0C0
+	.octa  0x3D027A280E1F92A03FF93737B0CDC5C0
+	.octa  0x3CF01C7C46B071F33FF9C49182A3F080
+	.octa  0x3CFC8B424491CAF83FFA5503B23E2540
+	.octa  0x3D06AF439A68BB993FFAE89F995AD380
+	.octa  0x3CDBAA9EC206AD4F3FFB7F76F2FB5E40
+	.octa  0x3CFC2220CB12A0923FFC199BDD855280
+	.octa  0x3D048A81E5E8F4A53FFCB720DCEF9040
+	.octa  0x3CDC976816BAD9B83FFD5818DCFBA480
+	.octa  0x3CFEB968CAC39ED33FFDFC97337B9B40
+	.octa  0x3CF9858F73A18F5E3FFEA4AFA2A490C0
+	.octa  0x3C99D3E12DD8A18B3FFF50765B6E4540
+
+.align 16
+.L__Five_Pont_FiveEMinus17:
+    .quad 0x3C90000000000000
+.L__B9:
+    .quad 0x3E5A2836AA646B96
+.L__B8:
+    .quad 0x3E928295484734EA
+.L__B7:
+    .quad 0x3EC71E14BFE3DB59
+.L__B6:
+    .quad 0x3EFA019F635825C4
+.L__B5:
+    .quad 0x3F2A01A01159DD2D
+.L__B4:
+    .quad 0x3F56C16C16CE14C6
+.L__B3:
+    .quad 0x3F8111111111A9F3
+.L__B2:
+    .quad 0x3FA55555555554B6
+.L__B1:
+    .quad 0x3FC5555555555549
+.L__TwopM7:
+    .quad 0x3F80000000000000
diff --git a/src/gas/expm1f.S b/src/gas/expm1f.S
new file mode 100644
index 0000000..6e7ca03
--- /dev/null
+++ b/src/gas/expm1f.S
@@ -0,0 +1,323 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(expm1f)
+#define fname_special _expm1f_special@PLT
+
+#ifdef __ELF__
+    .section .note.GNU-stack,"",@progbits
+#endif
+
+	.text
+	.p2align 4
+.globl fname
+	.type	fname, @function
+
+fname:
+    ucomiss .L__max_expm1_arg(%rip),%xmm0         ##if(x > max_expm1_arg)
+    ja .L__Max_Arg
+    jp .L__Max_Arg
+    ucomiss .L__log_OnePlus_OneByFour(%rip),%xmm0 ##if(x < log_OnePlus_OneByFour)
+    jae .L__Normal_Flow
+    ucomiss .L__log_OneMinus_OneByFour(%rip),%xmm0 ##if(x > log_OneMinus_OneByFour)
+    ja .L__Small_Arg
+    ucomiss .L__min_expm1_arg(%rip),%xmm0         ##if(x < min_expm1_arg)
+    jb .L__Min_Arg
+    
+    .p2align 4
+.L__Normal_Flow:
+    movaps %xmm0,%xmm1     #xmm1 = x
+    mulss .L__thirtyTwo_by_ln2(%rip),%xmm1   #xmm1 = x*thirtyTwo_by_ln2
+    movd %xmm1,%eax        #eax = x*thirtyTwo_by_ln2
+    and $0x80000000,%eax   #get the sign of x*thirtyTwo_by_ln2
+    or  $0x3F000000,%eax   #make +/- 0.5    
+    movd %eax,%xmm2        #xmm2 = +/- 0.5
+    addss %xmm2,%xmm1      #xmm1 = (x*32/ln2) +/- 0.5        
+	cvttps2dq %xmm1,%xmm2  #xmm2 = n = (int)(temp)
+	mov $0x0000001f,%edx
+	movd %edx,%xmm1
+	andps %xmm2,%xmm1      #xmm1 = j
+    movd %xmm2,%ecx        #ecx = n	
+	sarl	$5, %ecx       #ecx = m = n >> 5    
+	#xor %rdx,%rdx         #make it zeros, to be used for address	
+	movd %xmm1,%edx        #edx = j
+	lea  S_lead_and_trail_table(%rip),%rax	
+	movsd  (%rax,%rdx,8),%xmm3 #xmm3 = S_T,S_L
+    punpckldq %xmm2,%xmm1  #xmm1 = n,j    	
+	psubd %xmm1,%xmm2      #xmm2 = n1
+    punpcklqdq %xmm2,%xmm1 #xmm1 = n1,n,j    
+	cvtdq2ps %xmm1,%xmm1   #xmm1 = (float)(n1,n,j)
+		
+	#r2 = -(n*ln2_by_ThirtyTwo_trail);
+    #r1 = (x-n1*ln2_by_ThirtyTwo_lead) - j*ln2_by_ThirtyTwo_lead;	
+    mulps .L__Ln2By32_LeadTrailLead(%rip),%xmm1
+    movhlps %xmm1,%xmm2    #xmm2 = n1*ln2/32lead
+    movaps %xmm0,%xmm4     #xmm4 = x
+    subss %xmm2,%xmm4      #xmm4 = x - n1*ln2/32lead
+    subss %xmm1,%xmm4      #xmm4 = r1
+    psrldq $4,%xmm1        #xmm1 = -r2 should take care of sign later
+    
+    #r = r1 + r2;
+    movaps %xmm4,%xmm7     #xmm7 = r1   
+    subss %xmm1,%xmm4      #xmm4 = r = r1-(-r2) = r1 + r2
+    
+    #q = r*r*(B1+r*(B2));
+    movaps %xmm4,%xmm6         #xmm6 = r
+    mulss .L__B2_f(%rip),%xmm6 #xmm6 = r * B2
+    addss .L__B1_f(%rip),%xmm6 #xmm6 = B1 + (r * B2)
+    mulss %xmm4,%xmm6
+    mulss %xmm4,%xmm6          #xmm6 = q    
+    
+    #p = (r2+q) + r1;
+    subss %xmm1,%xmm6
+    addss %xmm7,%xmm6          #xmm6 = p
+
+    #s = S_L.f32 + S_T.f32;    
+    movdqa %xmm3,%xmm2     #xmm2 = S_T,S_L
+    psrldq $4,%xmm2        #xmm2 =     S_T
+    movaps %xmm2,%xmm5     #xmm5 =     S_T
+    addss %xmm3,%xmm2      #xmm2 = s    
+    
+    cmp  $0xfffffff9,%ecx  #Check m < -7
+    jl .L__M_Below_Minus7
+	cmp $23,%ecx           #Check m > 23
+	jg .L__M_Above_23
+	# -8 < m < 24
+    #twopm.f32 * ((S_L.f32 - twopmm.f32) + (S_L.f32*p+ S_T.f32 *(1+p)));
+    movaps %xmm3,%xmm2   #xmm2 = S_L
+    mulss %xmm6,%xmm2     #xmm2 = S_L * p
+    addss .L__One_f(%rip),%xmm6   #xmm6 = 1+p
+    mulss %xmm5,%xmm6     #xmm6 = S_T *(1+p)
+    addss %xmm6,%xmm2     #xmm2 = (S_L.f32*p+ S_T.f32 *(1+p))
+    mov $127,%eax
+    sub %ecx,%eax          #eax = 127 - m
+	shl  $23,%eax          #eax = 2^-m    
+    movd %eax,%xmm1    
+    subss %xmm1,%xmm3     #xmm3 = (S_L.f32 - twopmm.f32)
+    addss %xmm3,%xmm2     #xmm2 = ((S_L.f32 - twopmm.f32) + (S_L.f32*p+ S_T.f32 *(1+p)))   
+    shl  $23,%ecx
+    movd %ecx,%xmm0
+    paddd %xmm2,%xmm0
+    ret     
+   
+    .p2align 4
+.L__M_Below_Minus7:
+    #twopm.f32 * (S_L.f32 + (s*p + S_T.f32)) - 1;
+    mulss %xmm6,%xmm2     #xmm2 = s*p
+    addss %xmm5,%xmm2     #xmm2 = s*p + S_T
+    addss %xmm3,%xmm2     #xmm2 = (S_L.f32 + (s*p + S_T.f32))
+    shl  $23,%ecx  
+    movd %ecx,%xmm0
+    paddd %xmm2,%xmm0
+    subss .L__One_f(%rip),%xmm0            
+    ret  
+            
+    .p2align 4
+.L__M_Above_23:
+    #twopm.f32 * (S_L.f32 + (s*p+(S_T.f32 - twopmm.f32)));
+    cmp  $0x00000080,%ecx  #Check m < 128    
+    je .L__M_Equals_128        
+    cmp  $47,%ecx          #Check m > 47
+    ja .L__M_Above_47        
+    mov $127,%eax
+    sub %ecx,%eax          #eax = 127 - m
+	shl  $23,%eax          #eax = 2^-m    
+    movd %eax,%xmm1
+    subss %xmm1,%xmm5      #xmm5 = S_T.f32 - twopmm.f32
+    
+    .p2align 4
+.L__M_Above_47:    
+    shl  $23,%ecx    
+    mulss %xmm6,%xmm2      #xmm2 = s*p
+    addss %xmm5,%xmm2
+    addss %xmm3,%xmm2
+    movd %ecx,%xmm0
+    paddd %xmm2,%xmm0
+    ret    
+        
+    .p2align 4	
+.L__M_Equals_128:
+    mov $0x3f800000,%ecx  #127 at exponent
+    mulss %xmm6,%xmm2     #xmm2 = s*p
+    addss %xmm5,%xmm2     #xmm2 = s*p + S_T
+    addss %xmm3,%xmm2     #xmm2 = (S_L.f32 + (s*p + S_T.f32))
+    movd %ecx,%xmm1       #127
+    paddd %xmm2,%xmm1     #2^127*(S_L.f32 + (s*p + S_T.f32))
+    mov $0x00800000,%ecx  #multiply with one more 2
+    movd %ecx,%xmm2
+    paddd %xmm2,%xmm1
+    movd %xmm1,%ecx
+    and $0x7f800000,%ecx  #check if we reached +inf
+    cmp $0x7f800000,%ecx
+    je .L__Overflow
+    movdqa %xmm1,%xmm0
+    ret	
+	
+	.p2align 4
+.L__Small_Arg:
+    movd %xmm0,%eax
+    and $0x7fffffff,%eax    #eax = abs(x)
+    cmp $0x33000000,%eax    #check abs(x) < 2^-25
+    jl .L__VeryTiny_Arg
+    #log(1-1/4) < x < log(1+1/4)
+	#q = x*x*x*(A1 + x*(A2 + x*(A3 + x*(A4 + x*(A5)))));
+	movdqa %xmm0,%xmm1
+	mulss .L__A5_f(%rip),%xmm1
+	addss .L__A4_f(%rip),%xmm1
+	mulss %xmm0,%xmm1
+	addss .L__A3_f(%rip),%xmm1
+	mulss %xmm0,%xmm1
+	addss .L__A2_f(%rip),%xmm1
+	mulss %xmm0,%xmm1
+	addss .L__A1_f(%rip),%xmm1
+	mulss %xmm0,%xmm1
+	mulss %xmm0,%xmm1
+	mulss %xmm0,%xmm1
+	cvtps2pd %xmm0,%xmm2
+	movdqa %xmm2,%xmm0
+	mulsd %xmm0,%xmm2
+	mulsd .L__PointFive(%rip),%xmm2
+	addsd %xmm2,%xmm0
+	cvtps2pd %xmm1,%xmm2
+	addsd %xmm0,%xmm2
+	cvtpd2ps %xmm2,%xmm0	    
+    ret
+    
+	.p2align 4    
+.L__Min_Arg:
+    mov $0xBF800000,%eax
+    #call handle_error
+    movd %eax,%xmm0
+    ret    
+    
+	.p2align 4    
+.L__Max_Arg:
+    movd %xmm0,%eax
+    and $0x7fffffff,%eax    #eax = abs(x)
+    cmp $0x7f800000,%eax    #check for Nan
+    jae .L__Nan
+.L__Overflow:
+    mov $0x7f800000,%eax
+    #call handle_error
+    movd %eax,%xmm0
+    ret    
+.L__Nan:
+    and $0x007fffff,%eax
+    je .L__Overflow
+    addss %xmm0,%xmm0        
+    ret    
+
+    .p2align 4
+.L__VeryTiny_Arg:
+    #((twopm.f32 * x + xabs.f32) * twopmm.f32);
+	movd    %eax, %xmm1                                 #xmm1 = abs(x)																		
+	mov		$0x32000000, %eax 							#100 at exponent's place
+	movd	%eax, %xmm2
+	paddd	%xmm2, %xmm0								
+	addss	%xmm1, %xmm0
+	psubd   %xmm2, %xmm0
+	ret	    
+    
+.data
+.align 16
+.type	S_lead_and_trail_table, @object
+.size	S_lead_and_trail_table, 256
+S_lead_and_trail_table:
+	.quad	0x000000003F800000
+	.quad	0x355315853F82CD80
+	.quad	0x34D9F3123F85AAC0
+	.quad	0x35E8092E3F889800
+	.quad	0x3471F5463F8B95C0
+	.quad	0x36E62D173F8EA400
+	.quad	0x361B9D593F91C3C0
+	.quad	0x36BEA3FC3F94F4C0
+	.quad	0x36C146373F9837C0
+	.quad	0x36E6E7553F9B8D00
+	.quad	0x36C982473F9EF500
+	.quad	0x34C0C3123FA27040
+	.quad	0x36354D8B3FA5FEC0
+	.quad	0x3655A7543FA9A140
+	.quad	0x36FBA90B3FAD5800
+	.quad	0x36D6074B3FB123C0
+	.quad	0x36CCCFE73FB504C0
+	.quad	0x36BD1D8C3FB8FB80
+	.quad	0x368E7D603FBD0880
+	.quad	0x35CCA6673FC12C40
+	.quad	0x36A845543FC56700
+	.quad	0x36F619B93FC9B980
+	.quad	0x35C151F83FCE2480
+	.quad	0x366C8F893FD2A800
+	.quad	0x36F32B5A3FD744C0
+	.quad	0x36DE5F6C3FDBFB80
+	.quad	0x367761553FE0Ccc0
+	.quad	0x355CEF903FE5B900
+	.quad	0x355CFBA53FEAC0c0
+	.quad	0x36E66F733FEFE480
+	.quad	0x36F454923FF52540
+	.quad	0x36CB6DC93FFA8380
+
+.align 16
+.L__Ln2By32_LeadTrailLead:
+    .octa 0x333FBE8E3CB17200333FBE8E3CB17200
+    
+.L__max_expm1_arg:
+   .long 0x42B19999
+.L__log_OnePlus_OneByFour:
+   .long 0x3E647FBF
+  
+.L__log_OneMinus_OneByFour:
+   .long 0xBE934B11
+       
+.L__min_expm1_arg:
+   .long 0xC18AA122
+   
+.L__thirtyTwo_by_ln2:  
+   .long 0x4238AA3B
+  
+.align 16      
+.L__B2_f:
+   .long 0x3E2AAAEC      
+.L__B1_f:
+   .long 0x3F000044
+.L__One_f:
+   .long 0x3F800000  
+.L__PointFive:
+   .quad 0x3FE0000000000000
+
+.align 16
+.L__A1_f:
+   .long 0x3E2AAAAA   
+.L__A2_f:
+   .long 0x3D2AAAA0
+.L__A3_f:  
+   .long 0x3C0889FF     
+.L__A4_f:
+   .long 0x3AB64DE5
+.L__A5_f:
+   .long 0x394AB327
+    
+    
+
+    
+
diff --git a/src/gas/fabs.S b/src/gas/fabs.S
new file mode 100644
index 0000000..a436d0f
--- /dev/null
+++ b/src/gas/fabs.S
@@ -0,0 +1,63 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+# fabs.S
+#
+# An implementation of the fabs libm function.
+#
+# Prototype:
+#
+#     double fabs(double x);
+#
+
+#
+#   Algorithm: AND the Most Significant Bit of the 
+#              double precision number with 0 to get the 
+#              floating point absolute.
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(fabs)
+#define fname_special _fabs_special
+
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+    #input is in xmm0, which contains the final result also.
+    andpd .L__fabs_and_mask(%rip), %xmm0 # <result> latency = 3 
+    ret
+
+
+.align 16
+.L__fabs_and_mask:          .quad 0x7FFFFFFFFFFFFFFF
+                            .quad 0x0
+
+
diff --git a/src/gas/fabsf.S b/src/gas/fabsf.S
new file mode 100644
index 0000000..8a6ea27
--- /dev/null
+++ b/src/gas/fabsf.S
@@ -0,0 +1,67 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+# fabsf.S
+#
+# An implementation of the fabsf libm function.
+#
+# Prototype:
+#
+#     float fabsf(float x);
+#
+
+#
+#   Algorithm: AND the Most Significant Bit of the 
+#              single precision number with 0 to get the 
+#              floating point absolute.
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(fabsf)
+#define fname_special _fabsf_special
+
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+    #input is in xmm0, which contains the final result also.
+    andps .L__fabsf_and_mask(%rip), %xmm0 # <result> latency = 3 
+    ret
+
+
+.align 16
+.L__fabsf_and_mask:          .long 0x7FFFFFFF
+                             .long 0x0
+                             .quad 0x0
+
+
+
+
+
diff --git a/src/gas/fdim.S b/src/gas/fdim.S
new file mode 100644
index 0000000..14e382f
--- /dev/null
+++ b/src/gas/fdim.S
@@ -0,0 +1,63 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#fdim.S
+#
+# An implementation of the fdim libm function.
+#
+#  The fdim functions determine the positive difference between their arguments
+#	
+#	x - y if x > y
+#	+0    if x <= y
+#
+#
+#
+# Prototype:
+#
+#     double fdim(double x, double y)
+#
+
+#
+#   Algorithm:
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(fdim)
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+
+	MOVAPD 	%xmm0,%xmm2	
+	SUBSD   %xmm1,%xmm0 	
+	CMPNLESD %xmm1,%xmm2
+	ANDPD 	 %xmm2,%xmm0
+	
+    ret
diff --git a/src/gas/fdimf.S b/src/gas/fdimf.S
new file mode 100644
index 0000000..0b7a966
--- /dev/null
+++ b/src/gas/fdimf.S
@@ -0,0 +1,61 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#fdimf.S
+#
+# An implementation of the fdimf libm function.
+#
+#  The fdim functions determine the positive difference between their arguments
+#	
+#	x - y if x > y
+#	+0    if x <= y
+#
+# Prototype:
+#
+#     float fdimf(float x, float y)
+#
+
+#
+#   Algorithm:
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(fdimf)
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+
+	MOVAPD 	%xmm0,%xmm2	
+	SUBSS   %xmm1,%xmm0 	
+	CMPNLESS %xmm1,%xmm2
+	ANDPS 	 %xmm2,%xmm0
+	
+    ret
diff --git a/src/gas/fmax.S b/src/gas/fmax.S
new file mode 100644
index 0000000..ec0d787
--- /dev/null
+++ b/src/gas/fmax.S
@@ -0,0 +1,66 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#fmax.S
+#
+# An implementation of the fmax libm function.
+#
+# The fmax functions determine the maximum numeric value of their arguments.
+#
+# Prototype:
+#
+#     double fmax(double x, double y)
+#
+
+#
+#   Algorithm:
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(fmax)
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+
+	MOVAPD %xmm0,%xmm3		
+	
+	MAXSD  %xmm1,%xmm0	
+	MOVAPD %xmm0,%xmm2		
+
+	#If the input is nan then specal case to return the other operand	
+	CMPEQSD %xmm2,%xmm2	
+	PAND	%xmm2,%xmm0
+	
+	PANDN   %xmm3,%xmm2
+	POR		%xmm2,%xmm0
+
+    ret
+
diff --git a/src/gas/fmaxf.S b/src/gas/fmaxf.S
new file mode 100644
index 0000000..828832f
--- /dev/null
+++ b/src/gas/fmaxf.S
@@ -0,0 +1,66 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#fmaxf.S
+#
+# An implementation of the fmaxf libm function.
+#
+# The fmax functions determine the maximum numeric value of their arguments.
+#
+# Prototype:
+#
+#     float fmaxf(float x, float y)
+#
+
+#
+#   Algorithm:
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(fmaxf)
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+
+	MOVAPD %xmm0,%xmm3		
+	
+	MAXSS  %xmm1,%xmm0	
+	MOVAPD %xmm0,%xmm2		
+
+	#If the input is nan then specal case to return the other operand	
+	CMPEQSS %xmm2,%xmm2	
+	PAND	%xmm2,%xmm0
+	
+	PANDN   %xmm3,%xmm2
+	POR		%xmm2,%xmm0
+
+    ret
+
diff --git a/src/gas/fmin.S b/src/gas/fmin.S
new file mode 100644
index 0000000..79b3fb6
--- /dev/null
+++ b/src/gas/fmin.S
@@ -0,0 +1,66 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#fmin.S
+#
+# An implementation of the fmin libm function.
+#
+# The fmin functions determine the minimum numeric value of their arguments
+#
+# Prototype:
+#
+#     double fmin(double x, double y)
+#
+
+#
+#   Algorithm:
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(fmin)
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+
+	MOVAPD %xmm0,%xmm3		
+	
+	MINSD  %xmm1,%xmm0	
+	MOVAPD %xmm0,%xmm2		
+
+	#If the input is nan then specal case to return the other operand	
+	CMPEQSD %xmm2,%xmm2	
+	PAND	%xmm2,%xmm0
+	
+	PANDN   %xmm3,%xmm2
+	POR		%xmm2,%xmm0
+
+    ret
+
diff --git a/src/gas/fminf.S b/src/gas/fminf.S
new file mode 100644
index 0000000..34ee357
--- /dev/null
+++ b/src/gas/fminf.S
@@ -0,0 +1,66 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#fminf.S
+#
+# An implementation of the fminf libm function.
+#
+# The fmin functions determine the minimum numeric value of their arguments
+#
+#
+# Prototype:
+#
+#     float fminf(float x, float y)
+#
+
+#
+#   Algorithm:
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(fminf)
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+
+	MOVAPD %xmm0,%xmm3		
+	
+	MINSS  %xmm1,%xmm0	
+	MOVAPD %xmm0,%xmm2		
+
+	#If the input is nan then specal case to return the other operand	
+	CMPEQSS %xmm2,%xmm2	
+	PAND	%xmm2,%xmm0
+	
+	PANDN   %xmm3,%xmm2
+	POR		%xmm2,%xmm0	
+
+    ret
diff --git a/src/gas/fmod.S b/src/gas/fmod.S
new file mode 100644
index 0000000..bc1eeae
--- /dev/null
+++ b/src/gas/fmod.S
@@ -0,0 +1,223 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+# fmod.S
+#
+# An implementation of the fabs libm function.
+#
+# Prototype:
+#
+#     double fmod(double x,double y);
+#
+
+#
+#   Algorithm:
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(fmod)
+#define fname_special _fmod_special
+
+
+# local variable storage offsets
+.equ    temp_x, 0x0
+.equ    temp_y, 0x10
+.equ    stack_size,  0x28
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+    mov .L__exp_mask_64(%rip), %r10
+    #move the input to GP registers
+    movd %xmm0,%r8
+    movd %xmm1,%r9
+    movapd %xmm0,%xmm4
+    movapd %xmm1,%xmm5
+    movapd .L__Nan_64(%rip),%xmm6
+    and %r10,%r8
+    and %r10,%r9
+    ror $52, %r8
+    ror $52, %r9
+    #ifeither of the exponents is zero we do the fmod calculation in x87 mode
+    test %r8, %r8
+    jz  .L__LargeExpDiffComputation
+    mov %r9,%r10
+    test %r9, %r9
+    jz  .L__LargeExpDiffComputation
+    sub %r9,%r8 
+    cmp $52,%r8
+    jge .L__LargeExpDiffComputation
+    pand %xmm6,%xmm4
+    pand %xmm6,%xmm5
+    comisd %xmm5,%xmm4
+    jp  .L__InputIsNaN # if either of xmm1 or xmm0 is a NaN then 
+                       # parity flag is set
+    jz  .L__Input_Is_Equal
+    jbe .L__ReturnImmediate
+    cmp $0x7FF,%r8
+    jz  .L__Dividend_Is_Infinity
+
+    #calculation without using the x87 FPU
+.L__DirectComputation:
+    movapd %xmm4,%xmm2
+    movapd %xmm5,%xmm3
+    divsd %xmm3,%xmm2
+    cvttsd2siq %xmm2,%r8
+    cvtsi2sdq %r8,%xmm2
+
+    #multiplication in QUAD Precision
+    #Since the below commented multiplication resulted in an error
+    #we had to implement a quad precision multiplication.
+    #LOGIC behind Quad Precision Multiplication
+    #x = hx + tx   by setting x's last 27 bits to null
+    #y = hy + ty   similar to x
+    movapd .L__27bit_andingmask_64(%rip),%xmm4 
+    #movddup %xmm5,%xmm5 #[x,x]
+    #movddup %xmm2,%xmm2 #[y,y]
+
+    movapd %xmm5,%xmm1 # x
+    movapd %xmm2,%xmm6 # y
+    movapd %xmm2,%xmm7 # 
+    mulsd  %xmm5,%xmm7 # xmm7 = z = x*y
+    andpd  %xmm4,%xmm1
+    andpd  %xmm4,%xmm2
+    subsd  %xmm1,%xmm5 # xmm1 = hx   xmm5 = tx
+    subsd  %xmm2,%xmm6 # xmm2 = hy   xmm6 = ty
+
+    movapd %xmm1,%xmm4 # copy hx
+    mulsd  %xmm2,%xmm4 # xmm4 = hx*hy
+    subsd  %xmm7,%xmm4 # xmm4 = (hx*hy - z)
+    mulsd  %xmm6,%xmm1 # xmm1 = hx * ty
+    addsd  %xmm1,%xmm4 # xmm4 = ((hx * hy - *z) + hx * ty)
+    mulsd  %xmm5,%xmm2 # xmm2 = tx * hy
+    addsd  %xmm2,%xmm4 # xmm4 = (((hx * hy - *z) + hx * ty) + tx * hy)
+    mulsd  %xmm5,%xmm6 # xmm6 = tx * ty
+    addsd  %xmm4,%xmm6 # xmm6 = (((hx * hy - *z) + hx * ty) + tx * hy) + tx * ty;
+    #xmm6 and xmm7 contain the quad precision result
+    #v = dx - c;
+    #dx = v + (((dx - v) - c) - cc);
+    movapd %xmm0,%xmm1 # copy the input number
+    pand   .L__Nan_64(%rip),%xmm1
+    movapd %xmm1,%xmm2 # xmm2 = dx = xmm1
+    subsd  %xmm7,%xmm1 # v = dx - c
+    subsd  %xmm1,%xmm2 # (dx - v)
+    subsd  %xmm7,%xmm2 # ((dx - v) - c)
+    subsd  %xmm6,%xmm2 # (((dx - v) - c) - cc)
+    addsd  %xmm1,%xmm2 # xmm2 = dx = v + (((dx - v) - c) - cc) 
+                       # xmm3 = w
+    comisd .L__Zero_64(%rip),%xmm2
+    jae .L__positive
+    addsd  %xmm3,%xmm2
+.L__positive:    
+#  return x < 0.0? -dx : dx;
+.L__Finish:
+    comisd .L__Zero_64(%rip), %xmm0 
+    ja  .L__Not_Negative_Number1
+
+.L__Negative_Number1:
+    movapd .L__Zero_64(%rip),%xmm0
+    subsd  %xmm2,%xmm0
+    ret 
+.L__Not_Negative_Number1:
+    movapd %xmm2,%xmm0 
+    ret 
+
+    #calculation using the x87 FPU
+    #For numbers whose exponent of either of the divisor,
+    #or dividends are 0. Or for numbers whose exponential 
+    #diff is grater than 52
+.align 16
+.L__LargeExpDiffComputation:
+    sub $stack_size, %rsp
+    movsd %xmm0, temp_x(%rsp)
+    movsd %xmm1, temp_y(%rsp)
+    ffree %st(0)
+    ffree %st(1)
+    fldl  temp_y(%rsp)
+    fldl  temp_x(%rsp)
+    fnclex
+.align 32
+.L__repeat:    
+    fprem #Calculate remainder by dividing st(0) with st(1)
+          #fprem operation sets x87 condition codes, 
+          #it will set the C2 code to 1 if a partial remainder is calculated
+    fnstsw %ax 
+    and $0x0400,%ax # Stores Floating-Point Store Status Word into the accumulator
+                    # we need to check only the C2 bit of the Condition codes
+    cmp $0x0400,%ax # Checks whether the bit 10(C2) is set or not 
+                    # IF its set then a partial remainder was calculated
+    jz .L__repeat   
+    #store the result from the FPU stack to memory
+    fstpl   temp_x(%rsp) 
+    fstpl   temp_y(%rsp) 
+    movsd   temp_x(%rsp), %xmm0 
+    add $stack_size, %rsp
+    ret 
+
+    #IF both the inputs are equal
+.L__Input_Is_Equal:
+    cmp $0x7FF,%r8
+    jz .L__Dividend_Is_Infinity
+    cmp $0x7FF,%r9
+    jz .L__InputIsNaN
+    movsd %xmm0,%xmm1
+    pand .L__sign_mask_64(%rip),%xmm1
+    movsd .L__Zero_64(%rip),%xmm0
+    por  %xmm1,%xmm0
+    ret
+
+.L__InputIsNaN:
+    por .L__QNaN_mask_64(%rip),%xmm0
+    por .L__exp_mask_64(%rip),%xmm0
+.L__Dividend_Is_Infinity:
+    ret
+
+#Case when x < y
+.L__ReturnImmediate:
+    ret
+    
+
+
+.align 32    
+.L__sign_mask_64:          .quad 0x8000000000000000
+                           .quad 0x0
+.L__exp_mask_64:           .quad 0x7FF0000000000000
+                           .quad 0x0
+.L__27bit_andingmask_64:   .quad 0xfffffffff8000000
+                           .quad 0
+.L__2p52_mask_64:          .quad 0x4330000000000000 
+                           .quad 0
+.L__Zero_64:               .quad 0x0 
+                           .quad 0
+.L__QNaN_mask_64:          .quad 0x0008000000000000 
+                           .quad 0
+.L__Nan_64:                .quad 0x7FFFFFFFFFFFFFFF
+                           .quad 0
+
diff --git a/src/gas/fmodf.S b/src/gas/fmodf.S
new file mode 100644
index 0000000..c31d619
--- /dev/null
+++ b/src/gas/fmodf.S
@@ -0,0 +1,181 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+# fmodf.S
+#
+# An implementation of the fabs libm function.
+#
+# Prototype:
+#
+#     float fmodf(float x,float y);
+#
+
+#
+#   Algorithm:
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(fmodf)
+#define fname_special _fmodf_special
+
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+    mov .L__exp_mask_64(%rip), %rdi
+    movapd .L__sign_mask_64(%rip),%xmm6
+    cvtss2sd %xmm0,%xmm2 # double x
+    cvtss2sd %xmm1,%xmm3 # double y
+    pand %xmm6,%xmm2
+    pand %xmm6,%xmm3
+    movd %xmm2,%rax
+    movd %xmm3,%r8
+    mov %rax,%r11
+    mov %r8,%r9
+    movsd %xmm2,%xmm4
+    #take the exponents of both x and y
+    and %rdi,%rax
+    and %rdi,%r8
+    ror $52, %rax
+    ror $52, %r8
+    # ifeither of the exponents is infinity 
+    cmp $0X7FF,%rax 
+    jz  .L__InputIsNaN 
+    cmp $0X7FF,%r8 
+    jz  .L__InputIsNaNOrInf
+
+    cmp $0,%r8
+    jz  .L__Divisor_Is_Zero
+
+    cmp %r9, %r11
+    jz  .L__Input_Is_Equal
+    jb  .L__ReturnImmediate
+
+    xor %rcx,%rcx
+    mov $24,%rdx
+    movsd .L__One_64(%rip),%xmm7 # xmm7 = scale
+    cmp %rax,%r8 
+    jae .L__y_is_greater
+    #xmm3 = dy
+    sub %r8,%rax
+    div %dl       # al = ntimes
+    mov %al,%cl   # cl = ntimes
+    and $0xFF,%ax # set everything t o zero except al
+    mul %dl       # ax = dl * al = 24* ntimes
+    add $1023, %rax
+    shl $52,%rax
+    movd %rax,%xmm7 # xmm7 = scale
+.L__y_is_greater:
+    mulsd %xmm3,%xmm7 # xmm7 = scale * dy
+    movsd .L__2pminus24_decimal(%rip),%xmm6
+
+.align 16
+.L__Start_Loop:
+    dec %cl
+    js .L__End_Loop
+    divsd %xmm7,%xmm4     # xmm7 = (dx / w)
+    cvttsd2siq %xmm4,%rax 
+    cvtsi2sdq %rax,%xmm4  # xmm4 = t = (double)((int)(dx / w))
+    mulsd  %xmm7,%xmm4    # xmm4 = w*t
+    mulsd %xmm6,%xmm7     # w*= scale 
+    subsd  %xmm4,%xmm2    # xmm2 = dx -= w*t  
+    movsd %xmm2,%xmm4     # xmm4 = dx
+    jmp .L__Start_Loop
+.L__End_Loop:    
+    divsd %xmm7,%xmm4     # xmm7 = (dx / w)
+    cvttsd2siq %xmm4,%rax 
+    cvtsi2sdq %rax,%xmm4   # xmm4 = t = (double)((int)(dx / w))
+    mulsd  %xmm7,%xmm4    # xmm4 = w*t
+    subsd  %xmm4,%xmm2    # xmm2 = dx -= w*t  
+    comiss .L__Zero_64(%rip),%xmm0 
+    jb .L__Negative
+.L__Positive:
+    cvtsd2ss %xmm2,%xmm0 
+    ret
+.L__Negative:
+    movsd .L__MinusZero_64(%rip),%xmm0
+    subsd %xmm2,%xmm0
+    cvtsd2ss %xmm0,%xmm0 
+    ret
+
+.align 16
+.L__Input_Is_Equal:
+    cmp $0x7FF,%rax
+    jz .L__Dividend_Is_Infinity
+    cmp $0x7FF,%r8
+    jz .L__InputIsNaNOrInf
+    movsd %xmm0,%xmm1
+    pand .L__sign_bit_32(%rip),%xmm1
+    movss .L__Zero_64(%rip),%xmm0
+    por  %xmm1,%xmm0
+    ret
+
+.L__InputIsNaNOrInf:
+    comiss %xmm0,%xmm1
+    jp .L__InputIsNaN
+    ret 
+.L__Divisor_Is_Zero:    
+.L__InputIsNaN:
+    por .L__exp_mask_32(%rip),%xmm0
+.L__Dividend_Is_Infinity:
+    por .L__QNaN_mask_32(%rip),%xmm0
+    ret
+
+#Case when x < y
+.L__ReturnImmediate:
+    #xmm0 contains the input and is the result
+    ret
+        
+
+
+.align 32    
+.L__sign_bit_32:           .quad 0x8000000080000000
+                           .quad 0x0
+.L__exp_mask_64:           .quad 0x7FF0000000000000
+                           .quad 0x0
+.L__exp_mask_32:           .quad 0x000000007F800000
+                           .quad 0x0
+.L__27bit_andingmask_64:   .quad 0xfffffffff8000000
+                           .quad 0
+.L__2p52_mask_64:          .quad 0x4330000000000000 
+                           .quad 0
+.L__One_64:                .quad 0x3FF0000000000000 
+                           .quad 0
+.L__Zero_64:               .quad 0x0 
+                           .quad 0
+.L__MinusZero_64:          .quad 0x8000000000000000 
+                           .quad 0
+.L__QNaN_mask_32:          .quad 0x0000000000400000
+                           .quad 0
+.L__sign_mask_64:          .quad 0x7FFFFFFFFFFFFFFF
+                           .quad 0
+.L__2pminus24_decimal:     .quad 0x3E70000000000000
+                           .quad 0
+
diff --git a/src/gas/log.S b/src/gas/log.S
new file mode 100644
index 0000000..7068c6d
--- /dev/null
+++ b/src/gas/log.S
@@ -0,0 +1,1155 @@
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+#ifdef __x86_64__
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#
+# log.S
+#
+# An implementation of the log libm function.
+#
+# Prototype:
+#
+#     double log(double x);
+#
+
+#
+#   Algorithm:
+#
+#   Based on:
+#   Ping-Tak Peter Tang
+#   "Table-driven implementation of the logarithm function in IEEE
+#   floating-point arithmetic"
+#   ACM Transactions on Mathematical Software (TOMS)
+#   Volume 16, Issue 4 (December 1990)
+#
+#
+#   x very close to 1.0 is handled differently, for x everywhere else
+#   a brief explanation is given below
+#
+#   x = (2^m)*A
+#   x = (2^m)*(G+g) with (1 <= G < 2) and (g <= 2^(-9))
+#   x = (2^m)*2*(G/2+g/2)
+#   x = (2^m)*2*(F+f) with (0.5 <= F < 1) and (f <= 2^(-10))
+#   
+#   Y = (2^(-1))*(2^(-m))*(2^m)*A
+#   Now, range of Y is: 0.5 <= Y < 1
+#
+#   F = 0x100 + (first 8 mantissa bits) + (9th mantissa bit)
+#   Now, range of F is: 256 <= F <= 512
+#   F = F / 512
+#   Now, range of F is: 0.5 <= F <= 1
+#
+#   f = -(Y-F), with (f <= 2^(-10))
+#
+#   log(x) = m*log(2) + log(2) + log(F-f)
+#   log(x) = m*log(2) + log(2) + log(F) + log(1-(f/F))
+#   log(x) = m*log(2) + log(2*F) + log(1-r)
+#
+#   r = (f/F), with (r <= 2^(-9))
+#   r = f*(1/F) with (1/F) precomputed to avoid division
+#
+#   log(x) = m*log(2) + log(G) - poly
+#
+#   log(G) is precomputed
+#   poly = (r + (r^2)/2 + (r^3)/3 + (r^4)/4) + (r^5)/5) + (r^6)/6))
+#
+#   log(2) and log(G) need to be maintained in extra precision
+#   to avoid losing precision in the calculations
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(log)
+#define fname_special _log_special@PLT
+
+
+# local variable storage offsets
+.equ    p_temp, 0x0
+.equ    stack_size, 0x18
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+
+    sub         $stack_size, %rsp
+
+    # compute exponent part
+    xor         %rax, %rax
+    movdqa      %xmm0, %xmm3
+    movsd       %xmm0, %xmm4
+    psrlq       $52, %xmm3
+    movd        %xmm0, %rax
+    psubq       .L__mask_1023(%rip), %xmm3
+    movdqa      %xmm0, %xmm2
+    cvtdq2pd    %xmm3, %xmm6 # xexp
+
+    #  NaN or inf
+    movdqa      %xmm0, %xmm5
+    andpd       .L__real_inf(%rip), %xmm5
+    comisd      .L__real_inf(%rip), %xmm5
+    je          .L__x_is_inf_or_nan
+
+    # check for negative numbers or zero
+    xorpd       %xmm5, %xmm5
+    comisd      %xmm5, %xmm0
+    jbe         .L__x_is_zero_or_neg
+
+    pand        .L__real_mant(%rip), %xmm2
+    subsd       .L__real_one(%rip), %xmm4
+
+    comisd      .L__mask_1023_f(%rip), %xmm6
+    je          .L__denormal_adjust
+
+.L__continue_common:    
+
+    # compute index into the log tables
+    mov         %rax, %r9
+    and         .L__mask_mant_all8(%rip), %rax
+    and         .L__mask_mant9(%rip), %r9
+    shl         $1, %r9
+    add         %r9, %rax
+    mov         %rax, p_temp(%rsp)
+
+    # near one codepath
+    andpd       .L__real_notsign(%rip), %xmm4
+    comisd      .L__real_threshold(%rip), %xmm4
+    jb          .L__near_one
+
+    # F, Y
+    movsd       p_temp(%rsp), %xmm1
+    shr         $44, %rax
+    por         .L__real_half(%rip), %xmm2
+    por         .L__real_half(%rip), %xmm1
+    lea         .L__log_F_inv(%rip), %r9
+
+    # f = F - Y, r = f * inv
+    subsd       %xmm2, %xmm1
+    mulsd       (%r9,%rax,8), %xmm1
+
+    movsd       %xmm1, %xmm2
+    movsd       %xmm1, %xmm0
+    lea         .L__log_256_lead(%rip), %r9
+
+    # poly
+    movsd       .L__real_1_over_6(%rip), %xmm3
+    movsd       .L__real_1_over_3(%rip), %xmm1
+    mulsd       %xmm2, %xmm3                         
+    mulsd       %xmm2, %xmm1                         
+    mulsd       %xmm2, %xmm0                         
+    movsd       %xmm0, %xmm4
+    addsd       .L__real_1_over_5(%rip), %xmm3
+    addsd       .L__real_1_over_2(%rip), %xmm1
+    mulsd       %xmm0, %xmm4                         
+    mulsd       %xmm2, %xmm3                         
+    mulsd       %xmm0, %xmm1                         
+    addsd       .L__real_1_over_4(%rip), %xmm3
+    addsd       %xmm2, %xmm1                         
+    mulsd       %xmm4, %xmm3                         
+    addsd       %xmm3, %xmm1                         
+
+    # m*log(2) + log(G) - poly
+    movsd       .L__real_log2_tail(%rip), %xmm5
+    mulsd       %xmm6, %xmm5
+    subsd       %xmm1, %xmm5
+
+    movsd       (%r9,%rax,8), %xmm0
+    lea         .L__log_256_tail(%rip), %rdx
+    movsd       (%rdx,%rax,8), %xmm2
+    addsd       %xmm5, %xmm2
+
+    movsd       .L__real_log2_lead(%rip), %xmm4
+    mulsd       %xmm6, %xmm4
+    addsd       %xmm4, %xmm0
+
+    addsd       %xmm2, %xmm0
+
+    add         $stack_size, %rsp
+    ret
+
+.p2align 4,,15
+.L__near_one:
+
+    # r = x - 1.0
+    movsd       .L__real_two(%rip), %xmm2
+    subsd       .L__real_one(%rip), %xmm0 # r
+
+    addsd       %xmm0, %xmm2
+    movsd       %xmm0, %xmm1
+    divsd       %xmm2, %xmm1 # r/(2+r) = u/2
+
+    movsd       .L__real_ca2(%rip), %xmm4
+    movsd       .L__real_ca4(%rip), %xmm5
+
+    movsd       %xmm0, %xmm6
+    mulsd       %xmm1, %xmm6 # correction
+
+    addsd       %xmm1, %xmm1 # u
+    movsd       %xmm1, %xmm2
+
+    mulsd       %xmm1, %xmm2 # u^2
+
+    mulsd       %xmm2, %xmm4
+    mulsd       %xmm2, %xmm5
+
+    addsd       .L__real_ca1(%rip), %xmm4
+    addsd       .L__real_ca3(%rip), %xmm5
+
+    mulsd       %xmm1, %xmm2 # u^3
+    mulsd       %xmm2, %xmm4
+
+    mulsd       %xmm2, %xmm2
+    mulsd       %xmm1, %xmm2 # u^7
+    mulsd       %xmm2, %xmm5
+
+    addsd       %xmm5, %xmm4
+    subsd       %xmm6, %xmm4
+    addsd       %xmm4, %xmm0
+ 
+    add         $stack_size, %rsp
+    ret
+
+.L__denormal_adjust:
+    por         .L__real_one(%rip), %xmm2
+    subsd       .L__real_one(%rip), %xmm2
+    movsd       %xmm2, %xmm5
+    pand        .L__real_mant(%rip), %xmm2
+    movd        %xmm2, %rax
+    psrlq       $52, %xmm5
+    psubd       .L__mask_2045(%rip), %xmm5
+    cvtdq2pd    %xmm5, %xmm6
+    jmp         .L__continue_common
+
+.p2align 4,,15
+.L__x_is_zero_or_neg:
+    jne         .L__x_is_neg
+
+    movsd       .L__real_ninf(%rip), %xmm1
+    mov         .L__flag_x_zero(%rip), %edi
+    call        fname_special
+    jmp         .L__finish
+
+.p2align 4,,15
+.L__x_is_neg:
+
+    movsd       .L__real_qnan(%rip), %xmm1
+    mov         .L__flag_x_neg(%rip), %edi
+    call        fname_special
+    jmp         .L__finish
+
+.p2align 4,,15
+.L__x_is_inf_or_nan:
+
+    cmp         .L__real_inf(%rip), %rax
+    je          .L__finish
+
+    cmp         .L__real_ninf(%rip), %rax
+    je          .L__x_is_neg
+
+    mov         .L__real_qnanbit(%rip), %r9
+    and         %rax, %r9
+    jnz         .L__finish
+
+    or          .L__real_qnanbit(%rip), %rax
+    movd        %rax, %xmm1
+    mov         .L__flag_x_nan(%rip), %edi
+    call        fname_special
+    jmp         .L__finish    
+
+.p2align 4,,15
+.L__finish:
+    add         $stack_size, %rsp
+    ret
+
+
+.data
+
+.align 16
+
+# these codes and the ones in the corresponding .c file have to match
+.L__flag_x_zero:        .long 00000001
+.L__flag_x_neg:         .long 00000002
+.L__flag_x_nan:         .long 00000003
+
+.align 16
+
+.L__real_ninf:      .quad 0x0fff0000000000000   # -inf
+                    .quad 0x0000000000000000
+.L__real_inf:       .quad 0x7ff0000000000000    # +inf
+                    .quad 0x0000000000000000
+.L__real_qnan:      .quad 0x7ff8000000000000   # qNaN
+                    .quad 0x0000000000000000
+.L__real_qnanbit:   .quad 0x0008000000000000
+                    .quad 0x0000000000000000
+.L__real_mant:      .quad 0x000FFFFFFFFFFFFF    # mantissa bits
+                    .quad 0x0000000000000000
+.L__mask_1023:      .quad 0x00000000000003ff
+                    .quad 0x0000000000000000
+.L__mask_001:       .quad 0x0000000000000001
+                    .quad 0x0000000000000000
+
+.L__mask_mant_all8: .quad 0x000ff00000000000
+                    .quad 0x0000000000000000
+.L__mask_mant9:     .quad 0x0000080000000000
+                    .quad 0x0000000000000000
+
+.L__real_log2_lead: .quad 0x3fe62e42e0000000 # log2_lead  6.93147122859954833984e-01
+                    .quad 0x0000000000000000
+.L__real_log2_tail: .quad 0x3e6efa39ef35793c # log2_tail  5.76999904754328540596e-08
+                    .quad 0x0000000000000000
+
+.L__real_two:       .quad 0x4000000000000000 # 2
+                    .quad 0x0000000000000000
+
+.L__real_one:       .quad 0x3ff0000000000000 # 1
+                    .quad 0x0000000000000000
+
+.L__real_half:      .quad 0x3fe0000000000000 # 1/2
+                    .quad 0x0000000000000000
+
+.L__mask_100:       .quad 0x0000000000000100
+                    .quad 0x0000000000000000
+
+.L__real_1_over_512:    .quad 0x3f60000000000000
+                        .quad 0x0000000000000000
+
+.L__real_1_over_2:  .quad 0x3fe0000000000000
+                    .quad 0x0000000000000000
+.L__real_1_over_3:  .quad 0x3fd5555555555555
+                    .quad 0x0000000000000000
+.L__real_1_over_4:  .quad 0x3fd0000000000000
+                    .quad 0x0000000000000000
+.L__real_1_over_5:  .quad 0x3fc999999999999a
+                    .quad 0x0000000000000000
+.L__real_1_over_6:  .quad 0x3fc5555555555555
+                    .quad 0x0000000000000000
+
+.L__mask_1023_f:    .quad 0x0c08ff80000000000
+                    .quad 0x0000000000000000
+
+.L__mask_2045:      .quad 0x00000000000007fd
+                    .quad 0x0000000000000000
+
+.L__real_threshold: .quad 0x3fb0000000000000 # .0625
+                    .quad 0x0000000000000000
+
+.L__real_notsign:   .quad 0x7ffFFFFFFFFFFFFF # ^sign bit
+                    .quad 0x0000000000000000
+
+.L__real_ca1:       .quad 0x3fb55555555554e6 # 8.33333333333317923934e-02
+                    .quad 0x0000000000000000
+.L__real_ca2:       .quad 0x3f89999999bac6d4 # 1.25000000037717509602e-02
+                    .quad 0x0000000000000000
+.L__real_ca3:       .quad 0x3f62492307f1519f # 2.23213998791944806202e-03
+                    .quad 0x0000000000000000
+.L__real_ca4:       .quad 0x3f3c8034c85dfff0 # 4.34887777707614552256e-04
+                    .quad 0x0000000000000000
+
+.align 16
+.L__log_256_lead:
+                    .quad 0x0000000000000000
+                    .quad 0x3f6ff00aa0000000
+                    .quad 0x3f7fe02a60000000
+                    .quad 0x3f87dc4750000000
+                    .quad 0x3f8fc0a8b0000000
+                    .quad 0x3f93cea440000000
+                    .quad 0x3f97b91b00000000
+                    .quad 0x3f9b9fc020000000
+                    .quad 0x3f9f829b00000000
+                    .quad 0x3fa1b0d980000000
+                    .quad 0x3fa39e87b0000000
+                    .quad 0x3fa58a5ba0000000
+                    .quad 0x3fa77458f0000000
+                    .quad 0x3fa95c8300000000
+                    .quad 0x3fab42dd70000000
+                    .quad 0x3fad276b80000000
+                    .quad 0x3faf0a30c0000000
+                    .quad 0x3fb0759830000000
+                    .quad 0x3fb16536e0000000
+                    .quad 0x3fb253f620000000
+                    .quad 0x3fb341d790000000
+                    .quad 0x3fb42edcb0000000
+                    .quad 0x3fb51b0730000000
+                    .quad 0x3fb60658a0000000
+                    .quad 0x3fb6f0d280000000
+                    .quad 0x3fb7da7660000000
+                    .quad 0x3fb8c345d0000000
+                    .quad 0x3fb9ab4240000000
+                    .quad 0x3fba926d30000000
+                    .quad 0x3fbb78c820000000
+                    .quad 0x3fbc5e5480000000
+                    .quad 0x3fbd4313d0000000
+                    .quad 0x3fbe270760000000
+                    .quad 0x3fbf0a30c0000000
+                    .quad 0x3fbfec9130000000
+                    .quad 0x3fc0671510000000
+                    .quad 0x3fc0d77e70000000
+                    .quad 0x3fc1478580000000
+                    .quad 0x3fc1b72ad0000000
+                    .quad 0x3fc2266f10000000
+                    .quad 0x3fc29552f0000000
+                    .quad 0x3fc303d710000000
+                    .quad 0x3fc371fc20000000
+                    .quad 0x3fc3dfc2b0000000
+                    .quad 0x3fc44d2b60000000
+                    .quad 0x3fc4ba36f0000000
+                    .quad 0x3fc526e5e0000000
+                    .quad 0x3fc59338d0000000
+                    .quad 0x3fc5ff3070000000
+                    .quad 0x3fc66acd40000000
+                    .quad 0x3fc6d60fe0000000
+                    .quad 0x3fc740f8f0000000
+                    .quad 0x3fc7ab8900000000
+                    .quad 0x3fc815c0a0000000
+                    .quad 0x3fc87fa060000000
+                    .quad 0x3fc8e928d0000000
+                    .quad 0x3fc9525a90000000
+                    .quad 0x3fc9bb3620000000
+                    .quad 0x3fca23bc10000000
+                    .quad 0x3fca8becf0000000
+                    .quad 0x3fcaf3c940000000
+                    .quad 0x3fcb5b5190000000
+                    .quad 0x3fcbc28670000000
+                    .quad 0x3fcc296850000000
+                    .quad 0x3fcc8ff7c0000000
+                    .quad 0x3fccf63540000000
+                    .quad 0x3fcd5c2160000000
+                    .quad 0x3fcdc1bca0000000
+                    .quad 0x3fce270760000000
+                    .quad 0x3fce8c0250000000
+                    .quad 0x3fcef0adc0000000
+                    .quad 0x3fcf550a50000000
+                    .quad 0x3fcfb91860000000
+                    .quad 0x3fd00e6c40000000
+                    .quad 0x3fd0402590000000
+                    .quad 0x3fd071b850000000
+                    .quad 0x3fd0a324e0000000
+                    .quad 0x3fd0d46b50000000
+                    .quad 0x3fd1058bf0000000
+                    .quad 0x3fd1368700000000
+                    .quad 0x3fd1675ca0000000
+                    .quad 0x3fd1980d20000000
+                    .quad 0x3fd1c898c0000000
+                    .quad 0x3fd1f8ff90000000
+                    .quad 0x3fd22941f0000000
+                    .quad 0x3fd2596010000000
+                    .quad 0x3fd2895a10000000
+                    .quad 0x3fd2b93030000000
+                    .quad 0x3fd2e8e2b0000000
+                    .quad 0x3fd31871c0000000
+                    .quad 0x3fd347dd90000000
+                    .quad 0x3fd3772660000000
+                    .quad 0x3fd3a64c50000000
+                    .quad 0x3fd3d54fa0000000
+                    .quad 0x3fd4043080000000
+                    .quad 0x3fd432ef20000000
+                    .quad 0x3fd4618bc0000000
+                    .quad 0x3fd4900680000000
+                    .quad 0x3fd4be5f90000000
+                    .quad 0x3fd4ec9730000000
+                    .quad 0x3fd51aad80000000
+                    .quad 0x3fd548a2c0000000
+                    .quad 0x3fd5767710000000
+                    .quad 0x3fd5a42ab0000000
+                    .quad 0x3fd5d1bdb0000000
+                    .quad 0x3fd5ff3070000000
+                    .quad 0x3fd62c82f0000000
+                    .quad 0x3fd659b570000000
+                    .quad 0x3fd686c810000000
+                    .quad 0x3fd6b3bb20000000
+                    .quad 0x3fd6e08ea0000000
+                    .quad 0x3fd70d42e0000000
+                    .quad 0x3fd739d7f0000000
+                    .quad 0x3fd7664e10000000
+                    .quad 0x3fd792a550000000
+                    .quad 0x3fd7bede00000000
+                    .quad 0x3fd7eaf830000000
+                    .quad 0x3fd816f410000000
+                    .quad 0x3fd842d1d0000000
+                    .quad 0x3fd86e9190000000
+                    .quad 0x3fd89a3380000000
+                    .quad 0x3fd8c5b7c0000000
+                    .quad 0x3fd8f11e80000000
+                    .quad 0x3fd91c67e0000000
+                    .quad 0x3fd9479410000000
+                    .quad 0x3fd972a340000000
+                    .quad 0x3fd99d9580000000
+                    .quad 0x3fd9c86b00000000
+                    .quad 0x3fd9f323e0000000
+                    .quad 0x3fda1dc060000000
+                    .quad 0x3fda484090000000
+                    .quad 0x3fda72a490000000
+                    .quad 0x3fda9cec90000000
+                    .quad 0x3fdac718c0000000
+                    .quad 0x3fdaf12930000000
+                    .quad 0x3fdb1b1e00000000
+                    .quad 0x3fdb44f770000000
+                    .quad 0x3fdb6eb590000000
+                    .quad 0x3fdb985890000000
+                    .quad 0x3fdbc1e080000000
+                    .quad 0x3fdbeb4d90000000
+                    .quad 0x3fdc149ff0000000
+                    .quad 0x3fdc3dd7a0000000
+                    .quad 0x3fdc66f4e0000000
+                    .quad 0x3fdc8ff7c0000000
+                    .quad 0x3fdcb8e070000000
+                    .quad 0x3fdce1af00000000
+                    .quad 0x3fdd0a63a0000000
+                    .quad 0x3fdd32fe70000000
+                    .quad 0x3fdd5b7f90000000
+                    .quad 0x3fdd83e720000000
+                    .quad 0x3fddac3530000000
+                    .quad 0x3fddd46a00000000
+                    .quad 0x3fddfc8590000000
+                    .quad 0x3fde248810000000
+                    .quad 0x3fde4c71a0000000
+                    .quad 0x3fde744260000000
+                    .quad 0x3fde9bfa60000000
+                    .quad 0x3fdec399d0000000
+                    .quad 0x3fdeeb20c0000000
+                    .quad 0x3fdf128f50000000
+                    .quad 0x3fdf39e5b0000000
+                    .quad 0x3fdf6123f0000000
+                    .quad 0x3fdf884a30000000
+                    .quad 0x3fdfaf5880000000
+                    .quad 0x3fdfd64f20000000
+                    .quad 0x3fdffd2e00000000
+                    .quad 0x3fe011fab0000000
+                    .quad 0x3fe02552a0000000
+                    .quad 0x3fe0389ee0000000
+                    .quad 0x3fe04bdf90000000
+                    .quad 0x3fe05f14b0000000
+                    .quad 0x3fe0723e50000000
+                    .quad 0x3fe0855c80000000
+                    .quad 0x3fe0986f40000000
+                    .quad 0x3fe0ab76b0000000
+                    .quad 0x3fe0be72e0000000
+                    .quad 0x3fe0d163c0000000
+                    .quad 0x3fe0e44980000000
+                    .quad 0x3fe0f72410000000
+                    .quad 0x3fe109f390000000
+                    .quad 0x3fe11cb810000000
+                    .quad 0x3fe12f7190000000
+                    .quad 0x3fe1422020000000
+                    .quad 0x3fe154c3d0000000
+                    .quad 0x3fe1675ca0000000
+                    .quad 0x3fe179eab0000000
+                    .quad 0x3fe18c6e00000000
+                    .quad 0x3fe19ee6b0000000
+                    .quad 0x3fe1b154b0000000
+                    .quad 0x3fe1c3b810000000
+                    .quad 0x3fe1d610f0000000
+                    .quad 0x3fe1e85f50000000
+                    .quad 0x3fe1faa340000000
+                    .quad 0x3fe20cdcd0000000
+                    .quad 0x3fe21f0bf0000000
+                    .quad 0x3fe23130d0000000
+                    .quad 0x3fe2434b60000000
+                    .quad 0x3fe2555bc0000000
+                    .quad 0x3fe2676200000000
+                    .quad 0x3fe2795e10000000
+                    .quad 0x3fe28b5000000000
+                    .quad 0x3fe29d37f0000000
+                    .quad 0x3fe2af15f0000000
+                    .quad 0x3fe2c0e9e0000000
+                    .quad 0x3fe2d2b400000000
+                    .quad 0x3fe2e47430000000
+                    .quad 0x3fe2f62a90000000
+                    .quad 0x3fe307d730000000
+                    .quad 0x3fe3197a00000000
+                    .quad 0x3fe32b1330000000
+                    .quad 0x3fe33ca2b0000000
+                    .quad 0x3fe34e2890000000
+                    .quad 0x3fe35fa4e0000000
+                    .quad 0x3fe37117b0000000
+                    .quad 0x3fe38280f0000000
+                    .quad 0x3fe393e0d0000000
+                    .quad 0x3fe3a53730000000
+                    .quad 0x3fe3b68440000000
+                    .quad 0x3fe3c7c7f0000000
+                    .quad 0x3fe3d90260000000
+                    .quad 0x3fe3ea3390000000
+                    .quad 0x3fe3fb5b80000000
+                    .quad 0x3fe40c7a40000000
+                    .quad 0x3fe41d8fe0000000
+                    .quad 0x3fe42e9c60000000
+                    .quad 0x3fe43f9fe0000000
+                    .quad 0x3fe4509a50000000
+                    .quad 0x3fe4618bc0000000
+                    .quad 0x3fe4727430000000
+                    .quad 0x3fe48353d0000000
+                    .quad 0x3fe4942a80000000
+                    .quad 0x3fe4a4f850000000
+                    .quad 0x3fe4b5bd60000000
+                    .quad 0x3fe4c679a0000000
+                    .quad 0x3fe4d72d30000000
+                    .quad 0x3fe4e7d810000000
+                    .quad 0x3fe4f87a30000000
+                    .quad 0x3fe50913c0000000
+                    .quad 0x3fe519a4c0000000
+                    .quad 0x3fe52a2d20000000
+                    .quad 0x3fe53aad00000000
+                    .quad 0x3fe54b2460000000
+                    .quad 0x3fe55b9350000000
+                    .quad 0x3fe56bf9d0000000
+                    .quad 0x3fe57c57f0000000
+                    .quad 0x3fe58cadb0000000
+                    .quad 0x3fe59cfb20000000
+                    .quad 0x3fe5ad4040000000
+                    .quad 0x3fe5bd7d30000000
+                    .quad 0x3fe5cdb1d0000000
+                    .quad 0x3fe5ddde50000000
+                    .quad 0x3fe5ee02a0000000
+                    .quad 0x3fe5fe1ed0000000
+                    .quad 0x3fe60e32f0000000
+                    .quad 0x3fe61e3ef0000000
+                    .quad 0x3fe62e42e0000000
+                    .quad 0x0000000000000000
+
+.align 16
+.L__log_256_tail:
+                    .quad 0x0000000000000000
+                    .quad 0x3db5885e0250435a
+                    .quad 0x3de620cf11f86ed2
+                    .quad 0x3dff0214edba4a25
+                    .quad 0x3dbf807c79f3db4e
+                    .quad 0x3dea352ba779a52b
+                    .quad 0x3dff56c46aa49fd5
+                    .quad 0x3dfebe465fef5196
+                    .quad 0x3e0cf0660099f1f8
+                    .quad 0x3e1247b2ff85945d
+                    .quad 0x3e13fd7abf5202b6
+                    .quad 0x3e1f91c9a918d51e
+                    .quad 0x3e08cb73f118d3ca
+                    .quad 0x3e1d91c7d6fad074
+                    .quad 0x3de1971bec28d14c
+                    .quad 0x3e15b616a423c78a
+                    .quad 0x3da162a6617cc971
+                    .quad 0x3e166391c4c06d29
+                    .quad 0x3e2d46f5c1d0c4b8
+                    .quad 0x3e2e14282df1f6d3
+                    .quad 0x3e186f47424a660d
+                    .quad 0x3e2d4c8de077753e
+                    .quad 0x3e2e0c307ed24f1c
+                    .quad 0x3e226ea18763bdd3
+                    .quad 0x3e25cad69737c933
+                    .quad 0x3e2af62599088901
+                    .quad 0x3e18c66c83d6b2d0
+                    .quad 0x3e1880ceb36fb30f
+                    .quad 0x3e2495aac6ca17a4
+                    .quad 0x3e2761db4210878c
+                    .quad 0x3e2eb78e862bac2f
+                    .quad 0x3e19b2cd75790dd9
+                    .quad 0x3e2c55e5cbd3d50f
+                    .quad 0x3db162a6617cc971
+                    .quad 0x3dfdbeabaaa2e519
+                    .quad 0x3e1652cb7150c647
+                    .quad 0x3e39a11cb2cd2ee2
+                    .quad 0x3e219d0ab1a28813
+                    .quad 0x3e24bd9e80a41811
+                    .quad 0x3e3214b596faa3df
+                    .quad 0x3e303fea46980bb8
+                    .quad 0x3e31c8ffa5fd28c7
+                    .quad 0x3dce8f743bcd96c5
+                    .quad 0x3dfd98c5395315c6
+                    .quad 0x3e3996fa3ccfa7b2
+                    .quad 0x3e1cd2af2ad13037
+                    .quad 0x3e1d0da1bd17200e
+                    .quad 0x3e3330410ba68b75
+                    .quad 0x3df4f27a790e7c41
+                    .quad 0x3e13956a86f6ff1b
+                    .quad 0x3e2c6748723551d9
+                    .quad 0x3e2500de9326cdfc
+                    .quad 0x3e1086c848df1b59
+                    .quad 0x3e04357ead6836ff
+                    .quad 0x3e24832442408024
+                    .quad 0x3e3d10da8154b13d
+                    .quad 0x3e39e8ad68ec8260
+                    .quad 0x3e3cfbf706abaf18
+                    .quad 0x3e3fc56ac6326e23
+                    .quad 0x3e39105e3185cf21
+                    .quad 0x3e3d017fe5b19cc0
+                    .quad 0x3e3d1f6b48dd13fe
+                    .quad 0x3e20b63358a7e73a
+                    .quad 0x3e263063028c211c
+                    .quad 0x3e2e6a6886b09760
+                    .quad 0x3e3c138bb891cd03
+                    .quad 0x3e369f7722b7221a
+                    .quad 0x3df57d8fac1a628c
+                    .quad 0x3e3c55e5cbd3d50f
+                    .quad 0x3e1552d2ff48fe2e
+                    .quad 0x3e37b8b26ca431bc
+                    .quad 0x3e292decdc1c5f6d
+                    .quad 0x3e3abc7c551aaa8c
+                    .quad 0x3e36b540731a354b
+                    .quad 0x3e32d341036b89ef
+                    .quad 0x3e4f9ab21a3a2e0f
+                    .quad 0x3e239c871afb9fbd
+                    .quad 0x3e3e6add2c81f640
+                    .quad 0x3e435c95aa313f41
+                    .quad 0x3e249d4582f6cc53
+                    .quad 0x3e47574c1c07398f
+                    .quad 0x3e4ba846dece9e8d
+                    .quad 0x3e16999fafbc68e7
+                    .quad 0x3e4c9145e51b0103
+                    .quad 0x3e479ef2cb44850a
+                    .quad 0x3e0beec73de11275
+                    .quad 0x3e2ef4351af5a498
+                    .quad 0x3e45713a493b4a50
+                    .quad 0x3e45c23a61385992
+                    .quad 0x3e42a88309f57299
+                    .quad 0x3e4530faa9ac8ace
+                    .quad 0x3e25fec2d792a758
+                    .quad 0x3e35a517a71cbcd7
+                    .quad 0x3e3707dc3e1cd9a3
+                    .quad 0x3e3a1a9f8ef43049
+                    .quad 0x3e4409d0276b3674
+                    .quad 0x3e20e2f613e85bd9
+                    .quad 0x3df0027433001e5f
+                    .quad 0x3e35dde2836d3265
+                    .quad 0x3e2300134d7aaf04
+                    .quad 0x3e3cb7e0b42724f5
+                    .quad 0x3e2d6e93167e6308
+                    .quad 0x3e3d1569b1526adb
+                    .quad 0x3e0e99fc338a1a41
+                    .quad 0x3e4eb01394a11b1c
+                    .quad 0x3e04f27a790e7c41
+                    .quad 0x3e25ce3ca97b7af9
+                    .quad 0x3e281f0f940ed857
+                    .quad 0x3e4d36295d88857c
+                    .quad 0x3e21aca1ec4af526
+                    .quad 0x3e445743c7182726
+                    .quad 0x3e23c491aead337e
+                    .quad 0x3e3aef401a738931
+                    .quad 0x3e21cede76092a29
+                    .quad 0x3e4fba8f44f82bb4
+                    .quad 0x3e446f5f7f3c3e1a
+                    .quad 0x3e47055f86c9674b
+                    .quad 0x3e4b41a92b6b6e1a
+                    .quad 0x3e443d162e927628
+                    .quad 0x3e4466174013f9b1
+                    .quad 0x3e3b05096ad69c62
+                    .quad 0x3e40b169150faa58
+                    .quad 0x3e3cd98b1df85da7
+                    .quad 0x3e468b507b0f8fa8
+                    .quad 0x3e48422df57499ba
+                    .quad 0x3e11351586970274
+                    .quad 0x3e117e08acba92ee
+                    .quad 0x3e26e04314dd0229
+                    .quad 0x3e497f3097e56d1a
+                    .quad 0x3e3356e655901286
+                    .quad 0x3e0cb761457f94d6
+                    .quad 0x3e39af67a85a9dac
+                    .quad 0x3e453410931a909f
+                    .quad 0x3e22c587206058f5
+                    .quad 0x3e223bc358899c22
+                    .quad 0x3e4d7bf8b6d223cb
+                    .quad 0x3e47991ec5197ddb
+                    .quad 0x3e4a79e6bb3a9219
+                    .quad 0x3e3a4c43ed663ec5
+                    .quad 0x3e461b5a1484f438
+                    .quad 0x3e4b4e36f7ef0c3a
+                    .quad 0x3e115f026acd0d1b
+                    .quad 0x3e3f36b535cecf05
+                    .quad 0x3e2ffb7fbf3eb5c6
+                    .quad 0x3e3e6a6886b09760
+                    .quad 0x3e3135eb27f5bbc3
+                    .quad 0x3e470be7d6f6fa57
+                    .quad 0x3e4ce43cc84ab338
+                    .quad 0x3e4c01d7aac3bd91
+                    .quad 0x3e45c58d07961060
+                    .quad 0x3e3628bcf941456e
+                    .quad 0x3e4c58b2a8461cd2
+                    .quad 0x3e33071282fb989a
+                    .quad 0x3e420dab6a80f09c
+                    .quad 0x3e44f8d84c397b1e
+                    .quad 0x3e40d0ee08599e48
+                    .quad 0x3e1d68787e37da36
+                    .quad 0x3e366187d591bafc
+                    .quad 0x3e22346600bae772
+                    .quad 0x3e390377d0d61b8e
+                    .quad 0x3e4f5e0dd966b907
+                    .quad 0x3e49023cb79a00e2
+                    .quad 0x3e44e05158c28ad8
+                    .quad 0x3e3bfa7b08b18ae4
+                    .quad 0x3e4ef1e63db35f67
+                    .quad 0x3e0ec2ae39493d4f
+                    .quad 0x3e40afe930ab2fa0
+                    .quad 0x3e225ff8a1810dd4
+                    .quad 0x3e469743fb1a71a5
+                    .quad 0x3e5f9cc676785571
+                    .quad 0x3e5b524da4cbf982
+                    .quad 0x3e5a4c8b381535b8
+                    .quad 0x3e5839be809caf2c
+                    .quad 0x3e50968a1cb82c13
+                    .quad 0x3e5eae6a41723fb5
+                    .quad 0x3e5d9c29a380a4db
+                    .quad 0x3e4094aa0ada625e
+                    .quad 0x3e5973ad6fc108ca
+                    .quad 0x3e4747322fdbab97
+                    .quad 0x3e593692fa9d4221
+                    .quad 0x3e5c5a992dfbc7d9
+                    .quad 0x3e4e1f33e102387a
+                    .quad 0x3e464fbef14c048c
+                    .quad 0x3e4490f513ca5e3b
+                    .quad 0x3e37a6af4d4c799d
+                    .quad 0x3e57574c1c07398f
+                    .quad 0x3e57b133417f8c1c
+                    .quad 0x3e5feb9e0c176514
+                    .quad 0x3e419f25bb3172f7
+                    .quad 0x3e45f68a7bbfb852
+                    .quad 0x3e5ee278497929f1
+                    .quad 0x3e5ccee006109d58
+                    .quad 0x3e5ce081a07bd8b3
+                    .quad 0x3e570e12981817b8
+                    .quad 0x3e292ab6d93503d0
+                    .quad 0x3e58cb7dd7c3b61e
+                    .quad 0x3e4efafd0a0b78da
+                    .quad 0x3e5e907267c4288e
+                    .quad 0x3e5d31ef96780875
+                    .quad 0x3e23430dfcd2ad50
+                    .quad 0x3e344d88d75bc1f9
+                    .quad 0x3e5bec0f055e04fc
+                    .quad 0x3e5d85611590b9ad
+                    .quad 0x3df320568e583229
+                    .quad 0x3e5a891d1772f538
+                    .quad 0x3e22edc9dabba74d
+                    .quad 0x3e4b9009a1015086
+                    .quad 0x3e52a12a8c5b1a19
+                    .quad 0x3e3a7885f0fdac85
+                    .quad 0x3e5f4ffcd43ac691
+                    .quad 0x3e52243ae2640aad
+                    .quad 0x3e546513299035d3
+                    .quad 0x3e5b39c3a62dd725
+                    .quad 0x3e5ba6dd40049f51
+                    .quad 0x3e451d1ed7177409
+                    .quad 0x3e5cb0f2fd7f5216
+                    .quad 0x3e3ab150cd4e2213
+                    .quad 0x3e5cfd7bf3193844
+                    .quad 0x3e53fff8455f1dbd
+                    .quad 0x3e5fee640b905fc9
+                    .quad 0x3e54e2adf548084c
+                    .quad 0x3e3b597adc1ecdd2
+                    .quad 0x3e4345bd096d3a75
+                    .quad 0x3e5101b9d2453c8b
+                    .quad 0x3e508ce55cc8c979
+                    .quad 0x3e5bbf017e595f71
+                    .quad 0x3e37ce733bd393dc
+                    .quad 0x3e233bb0a503f8a1
+                    .quad 0x3e30e2f613e85bd9
+                    .quad 0x3e5e67555a635b3c
+                    .quad 0x3e2ea88df73d5e8b
+                    .quad 0x3e3d17e03bda18a8
+                    .quad 0x3e5b607d76044f7e
+                    .quad 0x3e52adc4e71bc2fc
+                    .quad 0x3e5f99dc7362d1d9
+                    .quad 0x3e5473fa008e6a6a
+                    .quad 0x3e2b75bb09cb0985
+                    .quad 0x3e5ea04dd10b9aba
+                    .quad 0x3e5802d0d6979674
+                    .quad 0x3e174688ccd99094
+                    .quad 0x3e496f16abb9df22
+                    .quad 0x3e46e66df2aa374f
+                    .quad 0x3e4e66525ea4550a
+                    .quad 0x3e42d02f34f20cbd
+                    .quad 0x3e46cfce65047188
+                    .quad 0x3e39b78c842d58b8
+                    .quad 0x3e4735e624c24bc9
+                    .quad 0x3e47eba1f7dd1adf
+                    .quad 0x3e586b3e59f65355
+                    .quad 0x3e1ce38e637f1b4d
+                    .quad 0x3e58d82ec919edc7
+                    .quad 0x3e4c52648ddcfa37
+                    .quad 0x3e52482ceae1ac12
+                    .quad 0x3e55a312311aba4f
+                    .quad 0x3e411e236329f225
+                    .quad 0x3e5b48c8cd2f246c
+                    .quad 0x3e6efa39ef35793c
+                    .quad 0x0000000000000000
+
+.align 16
+.L__log_F_inv:
+                    .quad 0x4000000000000000
+                    .quad 0x3fffe01fe01fe020
+                    .quad 0x3fffc07f01fc07f0
+                    .quad 0x3fffa11caa01fa12
+                    .quad 0x3fff81f81f81f820
+                    .quad 0x3fff6310aca0dbb5
+                    .quad 0x3fff44659e4a4271
+                    .quad 0x3fff25f644230ab5
+                    .quad 0x3fff07c1f07c1f08
+                    .quad 0x3ffee9c7f8458e02
+                    .quad 0x3ffecc07b301ecc0
+                    .quad 0x3ffeae807aba01eb
+                    .quad 0x3ffe9131abf0b767
+                    .quad 0x3ffe741aa59750e4
+                    .quad 0x3ffe573ac901e574
+                    .quad 0x3ffe3a9179dc1a73
+                    .quad 0x3ffe1e1e1e1e1e1e
+                    .quad 0x3ffe01e01e01e01e
+                    .quad 0x3ffde5d6e3f8868a
+                    .quad 0x3ffdca01dca01dca
+                    .quad 0x3ffdae6076b981db
+                    .quad 0x3ffd92f2231e7f8a
+                    .quad 0x3ffd77b654b82c34
+                    .quad 0x3ffd5cac807572b2
+                    .quad 0x3ffd41d41d41d41d
+                    .quad 0x3ffd272ca3fc5b1a
+                    .quad 0x3ffd0cb58f6ec074
+                    .quad 0x3ffcf26e5c44bfc6
+                    .quad 0x3ffcd85689039b0b
+                    .quad 0x3ffcbe6d9601cbe7
+                    .quad 0x3ffca4b3055ee191
+                    .quad 0x3ffc8b265afb8a42
+                    .quad 0x3ffc71c71c71c71c
+                    .quad 0x3ffc5894d10d4986
+                    .quad 0x3ffc3f8f01c3f8f0
+                    .quad 0x3ffc26b5392ea01c
+                    .quad 0x3ffc0e070381c0e0
+                    .quad 0x3ffbf583ee868d8b
+                    .quad 0x3ffbdd2b899406f7
+                    .quad 0x3ffbc4fd65883e7b
+                    .quad 0x3ffbacf914c1bad0
+                    .quad 0x3ffb951e2b18ff23
+                    .quad 0x3ffb7d6c3dda338b
+                    .quad 0x3ffb65e2e3beee05
+                    .quad 0x3ffb4e81b4e81b4f
+                    .quad 0x3ffb37484ad806ce
+                    .quad 0x3ffb2036406c80d9
+                    .quad 0x3ffb094b31d922a4
+                    .quad 0x3ffaf286bca1af28
+                    .quad 0x3ffadbe87f94905e
+                    .quad 0x3ffac5701ac5701b
+                    .quad 0x3ffaaf1d2f87ebfd
+                    .quad 0x3ffa98ef606a63be
+                    .quad 0x3ffa82e65130e159
+                    .quad 0x3ffa6d01a6d01a6d
+                    .quad 0x3ffa574107688a4a
+                    .quad 0x3ffa41a41a41a41a
+                    .quad 0x3ffa2c2a87c51ca0
+                    .quad 0x3ffa16d3f97a4b02
+                    .quad 0x3ffa01a01a01a01a
+                    .quad 0x3ff9ec8e951033d9
+                    .quad 0x3ff9d79f176b682d
+                    .quad 0x3ff9c2d14ee4a102
+                    .quad 0x3ff9ae24ea5510da
+                    .quad 0x3ff999999999999a
+                    .quad 0x3ff9852f0d8ec0ff
+                    .quad 0x3ff970e4f80cb872
+                    .quad 0x3ff95cbb0be377ae
+                    .quad 0x3ff948b0fcd6e9e0
+                    .quad 0x3ff934c67f9b2ce6
+                    .quad 0x3ff920fb49d0e229
+                    .quad 0x3ff90d4f120190d5
+                    .quad 0x3ff8f9c18f9c18fa
+                    .quad 0x3ff8e6527af1373f
+                    .quad 0x3ff8d3018d3018d3
+                    .quad 0x3ff8bfce8062ff3a
+                    .quad 0x3ff8acb90f6bf3aa
+                    .quad 0x3ff899c0f601899c
+                    .quad 0x3ff886e5f0abb04a
+                    .quad 0x3ff87427bcc092b9
+                    .quad 0x3ff8618618618618
+                    .quad 0x3ff84f00c2780614
+                    .quad 0x3ff83c977ab2bedd
+                    .quad 0x3ff82a4a0182a4a0
+                    .quad 0x3ff8181818181818
+                    .quad 0x3ff8060180601806
+                    .quad 0x3ff7f405fd017f40
+                    .quad 0x3ff7e225515a4f1d
+                    .quad 0x3ff7d05f417d05f4
+                    .quad 0x3ff7beb3922e017c
+                    .quad 0x3ff7ad2208e0ecc3
+                    .quad 0x3ff79baa6bb6398b
+                    .quad 0x3ff78a4c8178a4c8
+                    .quad 0x3ff77908119ac60d
+                    .quad 0x3ff767dce434a9b1
+                    .quad 0x3ff756cac201756d
+                    .quad 0x3ff745d1745d1746
+                    .quad 0x3ff734f0c541fe8d
+                    .quad 0x3ff724287f46debc
+                    .quad 0x3ff713786d9c7c09
+                    .quad 0x3ff702e05c0b8170
+                    .quad 0x3ff6f26016f26017
+                    .quad 0x3ff6e1f76b4337c7
+                    .quad 0x3ff6d1a62681c861
+                    .quad 0x3ff6c16c16c16c17
+                    .quad 0x3ff6b1490aa31a3d
+                    .quad 0x3ff6a13cd1537290
+                    .quad 0x3ff691473a88d0c0
+                    .quad 0x3ff6816816816817
+                    .quad 0x3ff6719f3601671a
+                    .quad 0x3ff661ec6a5122f9
+                    .quad 0x3ff6524f853b4aa3
+                    .quad 0x3ff642c8590b2164
+                    .quad 0x3ff63356b88ac0de
+                    .quad 0x3ff623fa77016240
+                    .quad 0x3ff614b36831ae94
+                    .quad 0x3ff6058160581606
+                    .quad 0x3ff5f66434292dfc
+                    .quad 0x3ff5e75bb8d015e7
+                    .quad 0x3ff5d867c3ece2a5
+                    .quad 0x3ff5c9882b931057
+                    .quad 0x3ff5babcc647fa91
+                    .quad 0x3ff5ac056b015ac0
+                    .quad 0x3ff59d61f123ccaa
+                    .quad 0x3ff58ed2308158ed
+                    .quad 0x3ff5805601580560
+                    .quad 0x3ff571ed3c506b3a
+                    .quad 0x3ff56397ba7c52e2
+                    .quad 0x3ff5555555555555
+                    .quad 0x3ff54725e6bb82fe
+                    .quad 0x3ff5390948f40feb
+                    .quad 0x3ff52aff56a8054b
+                    .quad 0x3ff51d07eae2f815
+                    .quad 0x3ff50f22e111c4c5
+                    .quad 0x3ff5015015015015
+                    .quad 0x3ff4f38f62dd4c9b
+                    .quad 0x3ff4e5e0a72f0539
+                    .quad 0x3ff4d843bedc2c4c
+                    .quad 0x3ff4cab88725af6e
+                    .quad 0x3ff4bd3edda68fe1
+                    .quad 0x3ff4afd6a052bf5b
+                    .quad 0x3ff4a27fad76014a
+                    .quad 0x3ff49539e3b2d067
+                    .quad 0x3ff4880522014880
+                    .quad 0x3ff47ae147ae147b
+                    .quad 0x3ff46dce34596066
+                    .quad 0x3ff460cbc7f5cf9a
+                    .quad 0x3ff453d9e2c776ca
+                    .quad 0x3ff446f86562d9fb
+                    .quad 0x3ff43a2730abee4d
+                    .quad 0x3ff42d6625d51f87
+                    .quad 0x3ff420b5265e5951
+                    .quad 0x3ff4141414141414
+                    .quad 0x3ff40782d10e6566
+                    .quad 0x3ff3fb013fb013fb
+                    .quad 0x3ff3ee8f42a5af07
+                    .quad 0x3ff3e22cbce4a902
+                    .quad 0x3ff3d5d991aa75c6
+                    .quad 0x3ff3c995a47babe7
+                    .quad 0x3ff3bd60d9232955
+                    .quad 0x3ff3b13b13b13b14
+                    .quad 0x3ff3a524387ac822
+                    .quad 0x3ff3991c2c187f63
+                    .quad 0x3ff38d22d366088e
+                    .quad 0x3ff3813813813814
+                    .quad 0x3ff3755bd1c945ee
+                    .quad 0x3ff3698df3de0748
+                    .quad 0x3ff35dce5f9f2af8
+                    .quad 0x3ff3521cfb2b78c1
+                    .quad 0x3ff34679ace01346
+                    .quad 0x3ff33ae45b57bcb2
+                    .quad 0x3ff32f5ced6a1dfa
+                    .quad 0x3ff323e34a2b10bf
+                    .quad 0x3ff3187758e9ebb6
+                    .quad 0x3ff30d190130d190
+                    .quad 0x3ff301c82ac40260
+                    .quad 0x3ff2f684bda12f68
+                    .quad 0x3ff2eb4ea1fed14b
+                    .quad 0x3ff2e025c04b8097
+                    .quad 0x3ff2d50a012d50a0
+                    .quad 0x3ff2c9fb4d812ca0
+                    .quad 0x3ff2bef98e5a3711
+                    .quad 0x3ff2b404ad012b40
+                    .quad 0x3ff2a91c92f3c105
+                    .quad 0x3ff29e4129e4129e
+                    .quad 0x3ff293725bb804a5
+                    .quad 0x3ff288b01288b013
+                    .quad 0x3ff27dfa38a1ce4d
+                    .quad 0x3ff27350b8812735
+                    .quad 0x3ff268b37cd60127
+                    .quad 0x3ff25e22708092f1
+                    .quad 0x3ff2539d7e9177b2
+                    .quad 0x3ff2492492492492
+                    .quad 0x3ff23eb79717605b
+                    .quad 0x3ff23456789abcdf
+                    .quad 0x3ff22a0122a0122a
+                    .quad 0x3ff21fb78121fb78
+                    .quad 0x3ff21579804855e6
+                    .quad 0x3ff20b470c67c0d9
+                    .quad 0x3ff2012012012012
+                    .quad 0x3ff1f7047dc11f70
+                    .quad 0x3ff1ecf43c7fb84c
+                    .quad 0x3ff1e2ef3b3fb874
+                    .quad 0x3ff1d8f5672e4abd
+                    .quad 0x3ff1cf06ada2811d
+                    .quad 0x3ff1c522fc1ce059
+                    .quad 0x3ff1bb4a4046ed29
+                    .quad 0x3ff1b17c67f2bae3
+                    .quad 0x3ff1a7b9611a7b96
+                    .quad 0x3ff19e0119e0119e
+                    .quad 0x3ff19453808ca29c
+                    .quad 0x3ff18ab083902bdb
+                    .quad 0x3ff1811811811812
+                    .quad 0x3ff1778a191bd684
+                    .quad 0x3ff16e0689427379
+                    .quad 0x3ff1648d50fc3201
+                    .quad 0x3ff15b1e5f75270d
+                    .quad 0x3ff151b9a3fdd5c9
+                    .quad 0x3ff1485f0e0acd3b
+                    .quad 0x3ff13f0e8d344724
+                    .quad 0x3ff135c81135c811
+                    .quad 0x3ff12c8b89edc0ac
+                    .quad 0x3ff12358e75d3033
+                    .quad 0x3ff11a3019a74826
+                    .quad 0x3ff1111111111111
+                    .quad 0x3ff107fbbe011080
+                    .quad 0x3ff0fef010fef011
+                    .quad 0x3ff0f5edfab325a2
+                    .quad 0x3ff0ecf56be69c90
+                    .quad 0x3ff0e40655826011
+                    .quad 0x3ff0db20a88f4696
+                    .quad 0x3ff0d24456359e3a
+                    .quad 0x3ff0c9714fbcda3b
+                    .quad 0x3ff0c0a7868b4171
+                    .quad 0x3ff0b7e6ec259dc8
+                    .quad 0x3ff0af2f722eecb5
+                    .quad 0x3ff0a6810a6810a7
+                    .quad 0x3ff09ddba6af8360
+                    .quad 0x3ff0953f39010954
+                    .quad 0x3ff08cabb37565e2
+                    .quad 0x3ff0842108421084
+                    .quad 0x3ff07b9f29b8eae2
+                    .quad 0x3ff073260a47f7c6
+                    .quad 0x3ff06ab59c7912fb
+                    .quad 0x3ff0624dd2f1a9fc
+                    .quad 0x3ff059eea0727586
+                    .quad 0x3ff05197f7d73404
+                    .quad 0x3ff04949cc1664c5
+                    .quad 0x3ff0410410410410
+                    .quad 0x3ff038c6b78247fc
+                    .quad 0x3ff03091b51f5e1a
+                    .quad 0x3ff02864fc7729e9
+                    .quad 0x3ff0204081020408
+                    .quad 0x3ff0182436517a37
+                    .quad 0x3ff0101010101010
+                    .quad 0x3ff0080402010080
+                    .quad 0x3ff0000000000000
+                    .quad 0x0000000000000000
+
+#endif
diff --git a/src/gas/log10.S b/src/gas/log10.S
new file mode 100644
index 0000000..90522ef
--- /dev/null
+++ b/src/gas/log10.S
@@ -0,0 +1,1146 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#
+# log10.S
+#
+# An implementation of the log10 libm function.
+#
+# Prototype:
+#
+#     double log10(double x);
+#
+
+#
+#   Algorithm:
+#       Similar to one presnted in log.S
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(log10)
+#define fname_special _log10_special@PLT
+
+
+# local variable storage offsets
+.equ    p_temp, 0x0
+.equ    stack_size, 0x18
+
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+
+    sub         $stack_size, %rsp
+
+    # compute exponent part
+    xor         %rax, %rax
+    movdqa      %xmm0, %xmm3
+    movsd       %xmm0, %xmm4
+    psrlq       $52, %xmm3
+    movd        %xmm0, %rax
+    psubq       .L__mask_1023(%rip), %xmm3
+    movdqa      %xmm0, %xmm2
+    cvtdq2pd    %xmm3, %xmm6 # xexp
+
+    #  NaN or inf
+    movdqa      %xmm0, %xmm5
+    andpd       .L__real_inf(%rip), %xmm5
+    comisd      .L__real_inf(%rip), %xmm5
+    je          .L__x_is_inf_or_nan
+
+    # check for negative numbers or zero
+    xorpd       %xmm5, %xmm5
+    comisd      %xmm5, %xmm0
+    jbe         .L__x_is_zero_or_neg
+
+    pand        .L__real_mant(%rip), %xmm2
+    subsd       .L__real_one(%rip), %xmm4
+
+    comisd      .L__mask_1023_f(%rip), %xmm6
+    je          .L__denormal_adjust
+
+.L__continue_common:    
+
+    # compute index into the log tables
+    mov         %rax, %r9
+    and         .L__mask_mant_all8(%rip), %rax
+    and         .L__mask_mant9(%rip), %r9
+    shl         $1, %r9
+    add         %r9, %rax
+    mov         %rax, p_temp(%rsp)
+
+    # near one codepath
+    andpd       .L__real_notsign(%rip), %xmm4
+    comisd      .L__real_threshold(%rip), %xmm4
+    jb          .L__near_one
+
+    # F, Y
+    movsd       p_temp(%rsp), %xmm1
+    shr         $44, %rax
+    por         .L__real_half(%rip), %xmm2
+    por         .L__real_half(%rip), %xmm1
+    lea         .L__log_F_inv(%rip), %r9
+
+    # f = F - Y, r = f * inv
+    subsd       %xmm2, %xmm1
+    mulsd       (%r9,%rax,8), %xmm1
+
+    movsd       %xmm1, %xmm2
+    movsd       %xmm1, %xmm0
+    lea         .L__log_256_lead(%rip), %r9
+
+    # poly
+    movsd       .L__real_1_over_6(%rip), %xmm3
+    movsd       .L__real_1_over_3(%rip), %xmm1
+    mulsd       %xmm2, %xmm3                         
+    mulsd       %xmm2, %xmm1                         
+    mulsd       %xmm2, %xmm0                         
+    movsd       %xmm0, %xmm4
+    addsd       .L__real_1_over_5(%rip), %xmm3
+    addsd       .L__real_1_over_2(%rip), %xmm1
+    mulsd       %xmm0, %xmm4                         
+    mulsd       %xmm2, %xmm3                         
+    mulsd       %xmm0, %xmm1                         
+    addsd       .L__real_1_over_4(%rip), %xmm3
+    addsd       %xmm2, %xmm1                         
+    mulsd       %xmm4, %xmm3                         
+    addsd       %xmm3, %xmm1                         
+
+    mulsd       .L__real_log10_e(%rip), %xmm1
+
+    # m*log(10) + log10(G) - poly
+    movsd       .L__real_log10_2_tail(%rip), %xmm5
+    mulsd       %xmm6, %xmm5
+    subsd       %xmm1, %xmm5
+
+    movsd       (%r9,%rax,8), %xmm0
+    lea         .L__log_256_tail(%rip), %rdx
+    movsd       (%rdx,%rax,8), %xmm2
+    addsd       %xmm5, %xmm2
+
+    movsd       .L__real_log10_2_lead(%rip), %xmm4
+    mulsd       %xmm6, %xmm4
+    addsd       %xmm4, %xmm0
+
+    addsd       %xmm2, %xmm0
+
+    add         $stack_size, %rsp
+    ret
+
+.p2align 4,,15
+.L__near_one:
+
+    # r = x - 1.0
+    movsd       .L__real_two(%rip), %xmm2
+    subsd       .L__real_one(%rip), %xmm0 # r
+
+    addsd       %xmm0, %xmm2
+    movsd       %xmm0, %xmm1
+    divsd       %xmm2, %xmm1 # r/(2+r) = u/2
+
+    movsd       .L__real_ca2(%rip), %xmm4
+    movsd       .L__real_ca4(%rip), %xmm5
+
+    movsd       %xmm0, %xmm6
+    mulsd       %xmm1, %xmm6 # correction
+
+    addsd       %xmm1, %xmm1 # u
+    movsd       %xmm1, %xmm2
+
+    mulsd       %xmm1, %xmm2 # u^2
+
+    mulsd       %xmm2, %xmm4
+    mulsd       %xmm2, %xmm5
+
+    addsd       .L__real_ca1(%rip), %xmm4
+    addsd       .L__real_ca3(%rip), %xmm5
+
+    mulsd       %xmm1, %xmm2 # u^3
+    mulsd       %xmm2, %xmm4
+
+    mulsd       %xmm2, %xmm2
+    mulsd       %xmm1, %xmm2 # u^7
+    mulsd       %xmm2, %xmm5
+
+    addsd       %xmm5, %xmm4
+    subsd       %xmm6, %xmm4
+
+    movdqa      %xmm0, %xmm3
+    pand        .L__mask_lower(%rip), %xmm3
+    subsd       %xmm3, %xmm0
+    addsd       %xmm0, %xmm4
+
+    movsd       %xmm3, %xmm0
+    movsd       %xmm4, %xmm1
+
+    mulsd       .L__real_log10_e_tail(%rip), %xmm4
+    mulsd       .L__real_log10_e_tail(%rip), %xmm0
+    mulsd       .L__real_log10_e_lead(%rip), %xmm1
+    mulsd       .L__real_log10_e_lead(%rip), %xmm3
+
+    addsd       %xmm4, %xmm0
+    addsd       %xmm1, %xmm0
+    addsd       %xmm3, %xmm0
+
+    add         $stack_size, %rsp
+    ret
+
+.L__denormal_adjust:
+    por         .L__real_one(%rip), %xmm2
+    subsd       .L__real_one(%rip), %xmm2
+    movsd       %xmm2, %xmm5
+    pand        .L__real_mant(%rip), %xmm2
+    movd        %xmm2, %rax
+    psrlq       $52, %xmm5
+    psubd       .L__mask_2045(%rip), %xmm5
+    cvtdq2pd    %xmm5, %xmm6
+    jmp         .L__continue_common
+
+.p2align 4,,15
+.L__x_is_zero_or_neg:
+    jne         .L__x_is_neg
+
+    movsd       .L__real_ninf(%rip), %xmm1
+    mov         .L__flag_x_zero(%rip), %edi
+    call        fname_special
+    jmp         .L__finish
+
+.p2align 4,,15
+.L__x_is_neg:
+
+    movsd       .L__real_qnan(%rip), %xmm1
+    mov         .L__flag_x_neg(%rip), %edi
+    call        fname_special
+    jmp         .L__finish
+
+.p2align 4,,15
+.L__x_is_inf_or_nan:
+
+    cmp         .L__real_inf(%rip), %rax
+    je          .L__finish
+
+    cmp         .L__real_ninf(%rip), %rax
+    je          .L__x_is_neg
+
+    mov         .L__real_qnanbit(%rip), %r9
+    and         %rax, %r9
+    jnz         .L__finish
+
+    or          .L__real_qnanbit(%rip), %rax
+    movd        %rax, %xmm1
+    mov         .L__flag_x_nan(%rip), %edi
+    call        fname_special
+    jmp         .L__finish    
+
+.p2align 4,,15
+.L__finish:
+    add         $stack_size, %rsp
+    ret
+
+
+.data
+
+.align 16
+
+# these codes and the ones in the corresponding .c file have to match
+.L__flag_x_zero:        .long 00000001
+.L__flag_x_neg:         .long 00000002
+.L__flag_x_nan:         .long 00000003
+
+.align 16
+
+.L__real_ninf:      .quad 0x0fff0000000000000   # -inf
+                    .quad 0x0000000000000000
+.L__real_inf:       .quad 0x7ff0000000000000    # +inf
+                    .quad 0x0000000000000000
+.L__real_qnan:      .quad 0x7ff8000000000000   # qNaN
+                    .quad 0x0000000000000000
+.L__real_qnanbit:   .quad 0x0008000000000000
+                    .quad 0x0000000000000000
+.L__real_mant:      .quad 0x000FFFFFFFFFFFFF    # mantissa bits
+                    .quad 0x0000000000000000
+.L__mask_1023:      .quad 0x00000000000003ff
+                    .quad 0x0000000000000000
+.L__mask_001:       .quad 0x0000000000000001
+                    .quad 0x0000000000000000
+
+.L__mask_mant_all8:     .quad 0x000ff00000000000
+                        .quad 0x0000000000000000
+.L__mask_mant9:         .quad 0x0000080000000000
+                        .quad 0x0000000000000000
+
+.L__real_log10_e:       .quad 0x3fdbcb7b1526e50e
+                        .quad 0x0000000000000000
+
+.L__real_log10_e_lead:  .quad 0x3fdbcb7800000000 # log10e_lead 4.34293746948242187500e-01
+                        .quad 0x0000000000000000
+.L__real_log10_e_tail:  .quad 0x3ea8a93728719535 # log10e_tail 7.3495500964015109100644e-7
+                        .quad 0x0000000000000000
+
+.L__real_log10_2_lead:  .quad 0x3fd3441350000000
+                        .quad 0x0000000000000000
+.L__real_log10_2_tail:  .quad 0x3e03ef3fde623e25
+                        .quad 0x0000000000000000
+
+
+
+
+.L__real_two:       .quad 0x4000000000000000 # 2
+                    .quad 0x0000000000000000
+
+.L__real_one:       .quad 0x3ff0000000000000 # 1
+                    .quad 0x0000000000000000
+
+.L__real_half:      .quad 0x3fe0000000000000 # 1/2
+                    .quad 0x0000000000000000
+
+.L__mask_100:       .quad 0x0000000000000100
+                    .quad 0x0000000000000000
+
+.L__real_1_over_512:    .quad 0x3f60000000000000
+                        .quad 0x0000000000000000
+
+.L__real_1_over_2:  .quad 0x3fe0000000000000
+                    .quad 0x0000000000000000
+.L__real_1_over_3:  .quad 0x3fd5555555555555
+                    .quad 0x0000000000000000
+.L__real_1_over_4:  .quad 0x3fd0000000000000
+                    .quad 0x0000000000000000
+.L__real_1_over_5:  .quad 0x3fc999999999999a
+                    .quad 0x0000000000000000
+.L__real_1_over_6:  .quad 0x3fc5555555555555
+                    .quad 0x0000000000000000
+
+.L__mask_1023_f:    .quad 0x0c08ff80000000000
+                    .quad 0x0000000000000000
+
+.L__mask_2045:      .quad 0x00000000000007fd
+                    .quad 0x0000000000000000
+
+.L__real_threshold: .quad 0x3fb0000000000000 # .0625
+                    .quad 0x0000000000000000
+
+.L__real_notsign:   .quad 0x7ffFFFFFFFFFFFFF # ^sign bit
+                    .quad 0x0000000000000000
+
+.L__real_ca1:       .quad 0x3fb55555555554e6 # 8.33333333333317923934e-02
+                    .quad 0x0000000000000000
+.L__real_ca2:       .quad 0x3f89999999bac6d4 # 1.25000000037717509602e-02
+                    .quad 0x0000000000000000
+.L__real_ca3:       .quad 0x3f62492307f1519f # 2.23213998791944806202e-03
+                    .quad 0x0000000000000000
+.L__real_ca4:       .quad 0x3f3c8034c85dfff0 # 4.34887777707614552256e-04
+                    .quad 0x0000000000000000
+
+.L__mask_lower:     .quad 0x0ffffffff00000000
+                    .quad 0x0000000000000000
+
+.align 16
+.L__log_256_lead:
+                    .quad 0x0000000000000000
+                    .quad 0x3f5bbd9e90000000
+                    .quad 0x3f6bafd470000000
+                    .quad 0x3f74b99560000000
+                    .quad 0x3f7b9476a0000000
+                    .quad 0x3f81344da0000000
+                    .quad 0x3f849b0850000000
+                    .quad 0x3f87fe71c0000000
+                    .quad 0x3f8b5e9080000000
+                    .quad 0x3f8ebb6af0000000
+                    .quad 0x3f910a83a0000000
+                    .quad 0x3f92b5b5e0000000
+                    .quad 0x3f945f4f50000000
+                    .quad 0x3f96075300000000
+                    .quad 0x3f97adc3d0000000
+                    .quad 0x3f9952a4f0000000
+                    .quad 0x3f9af5f920000000
+                    .quad 0x3f9c97c370000000
+                    .quad 0x3f9e3806a0000000
+                    .quad 0x3f9fd6c5b0000000
+                    .quad 0x3fa0ba01a0000000
+                    .quad 0x3fa187e120000000
+                    .quad 0x3fa25502c0000000
+                    .quad 0x3fa32167c0000000
+                    .quad 0x3fa3ed1190000000
+                    .quad 0x3fa4b80180000000
+                    .quad 0x3fa58238e0000000
+                    .quad 0x3fa64bb910000000
+                    .quad 0x3fa7148340000000
+                    .quad 0x3fa7dc98c0000000
+                    .quad 0x3fa8a3fad0000000
+                    .quad 0x3fa96aaac0000000
+                    .quad 0x3faa30a9d0000000
+                    .quad 0x3faaf5f920000000
+                    .quad 0x3fabba9a00000000
+                    .quad 0x3fac7e8d90000000
+                    .quad 0x3fad41d510000000
+                    .quad 0x3fae0471a0000000
+                    .quad 0x3faec66470000000
+                    .quad 0x3faf87aeb0000000
+                    .quad 0x3fb02428c0000000
+                    .quad 0x3fb08426f0000000
+                    .quad 0x3fb0e3d290000000
+                    .quad 0x3fb1432c30000000
+                    .quad 0x3fb1a23440000000
+                    .quad 0x3fb200eb60000000
+                    .quad 0x3fb25f5210000000
+                    .quad 0x3fb2bd68e0000000
+                    .quad 0x3fb31b3050000000
+                    .quad 0x3fb378a8e0000000
+                    .quad 0x3fb3d5d330000000
+                    .quad 0x3fb432afa0000000
+                    .quad 0x3fb48f3ed0000000
+                    .quad 0x3fb4eb8120000000
+                    .quad 0x3fb5477730000000
+                    .quad 0x3fb5a32160000000
+                    .quad 0x3fb5fe8040000000
+                    .quad 0x3fb6599440000000
+                    .quad 0x3fb6b45df0000000
+                    .quad 0x3fb70eddb0000000
+                    .quad 0x3fb7691400000000
+                    .quad 0x3fb7c30160000000
+                    .quad 0x3fb81ca630000000
+                    .quad 0x3fb8760300000000
+                    .quad 0x3fb8cf1830000000
+                    .quad 0x3fb927e640000000
+                    .quad 0x3fb9806d90000000
+                    .quad 0x3fb9d8aea0000000
+                    .quad 0x3fba30a9d0000000
+                    .quad 0x3fba885fa0000000
+                    .quad 0x3fbadfd070000000
+                    .quad 0x3fbb36fcb0000000
+                    .quad 0x3fbb8de4d0000000
+                    .quad 0x3fbbe48930000000
+                    .quad 0x3fbc3aea40000000
+                    .quad 0x3fbc910870000000
+                    .quad 0x3fbce6e410000000
+                    .quad 0x3fbd3c7da0000000
+                    .quad 0x3fbd91d580000000
+                    .quad 0x3fbde6ec00000000
+                    .quad 0x3fbe3bc1a0000000
+                    .quad 0x3fbe9056b0000000
+                    .quad 0x3fbee4aba0000000
+                    .quad 0x3fbf38c0c0000000
+                    .quad 0x3fbf8c9680000000
+                    .quad 0x3fbfe02d30000000
+                    .quad 0x3fc019c2a0000000
+                    .quad 0x3fc0434f70000000
+                    .quad 0x3fc06cbd60000000
+                    .quad 0x3fc0960c80000000
+                    .quad 0x3fc0bf3d00000000
+                    .quad 0x3fc0e84f10000000
+                    .quad 0x3fc11142f0000000
+                    .quad 0x3fc13a18a0000000
+                    .quad 0x3fc162d080000000
+                    .quad 0x3fc18b6a90000000
+                    .quad 0x3fc1b3e710000000
+                    .quad 0x3fc1dc4630000000
+                    .quad 0x3fc2048810000000
+                    .quad 0x3fc22cace0000000
+                    .quad 0x3fc254b4d0000000
+                    .quad 0x3fc27c9ff0000000
+                    .quad 0x3fc2a46e80000000
+                    .quad 0x3fc2cc20b0000000
+                    .quad 0x3fc2f3b690000000
+                    .quad 0x3fc31b3050000000
+                    .quad 0x3fc3428e20000000
+                    .quad 0x3fc369d020000000
+                    .quad 0x3fc390f680000000
+                    .quad 0x3fc3b80160000000
+                    .quad 0x3fc3def0e0000000
+                    .quad 0x3fc405c530000000
+                    .quad 0x3fc42c7e70000000
+                    .quad 0x3fc4531cd0000000
+                    .quad 0x3fc479a070000000
+                    .quad 0x3fc4a00970000000
+                    .quad 0x3fc4c65800000000
+                    .quad 0x3fc4ec8c30000000
+                    .quad 0x3fc512a640000000
+                    .quad 0x3fc538a630000000
+                    .quad 0x3fc55e8c50000000
+                    .quad 0x3fc5845890000000
+                    .quad 0x3fc5aa0b40000000
+                    .quad 0x3fc5cfa470000000
+                    .quad 0x3fc5f52440000000
+                    .quad 0x3fc61a8ad0000000
+                    .quad 0x3fc63fd850000000
+                    .quad 0x3fc6650cd0000000
+                    .quad 0x3fc68a2880000000
+                    .quad 0x3fc6af2b80000000
+                    .quad 0x3fc6d415e0000000
+                    .quad 0x3fc6f8e7d0000000
+                    .quad 0x3fc71da170000000
+                    .quad 0x3fc74242e0000000
+                    .quad 0x3fc766cc40000000
+                    .quad 0x3fc78b3da0000000
+                    .quad 0x3fc7af9730000000
+                    .quad 0x3fc7d3d910000000
+                    .quad 0x3fc7f80350000000
+                    .quad 0x3fc81c1620000000
+                    .quad 0x3fc8401190000000
+                    .quad 0x3fc863f5c0000000
+                    .quad 0x3fc887c2e0000000
+                    .quad 0x3fc8ab7900000000
+                    .quad 0x3fc8cf1830000000
+                    .quad 0x3fc8f2a0a0000000
+                    .quad 0x3fc9161270000000
+                    .quad 0x3fc9396db0000000
+                    .quad 0x3fc95cb280000000
+                    .quad 0x3fc97fe100000000
+                    .quad 0x3fc9a2f950000000
+                    .quad 0x3fc9c5fb70000000
+                    .quad 0x3fc9e8e7b0000000
+                    .quad 0x3fca0bbdf0000000
+                    .quad 0x3fca2e7e80000000
+                    .quad 0x3fca512960000000
+                    .quad 0x3fca73bea0000000
+                    .quad 0x3fca963e70000000
+                    .quad 0x3fcab8a8f0000000
+                    .quad 0x3fcadafe20000000
+                    .quad 0x3fcafd3e30000000
+                    .quad 0x3fcb1f6930000000
+                    .quad 0x3fcb417f40000000
+                    .quad 0x3fcb638070000000
+                    .quad 0x3fcb856cf0000000
+                    .quad 0x3fcba744b0000000
+                    .quad 0x3fcbc907f0000000
+                    .quad 0x3fcbeab6c0000000
+                    .quad 0x3fcc0c5130000000
+                    .quad 0x3fcc2dd750000000
+                    .quad 0x3fcc4f4950000000
+                    .quad 0x3fcc70a740000000
+                    .quad 0x3fcc91f130000000
+                    .quad 0x3fccb32740000000
+                    .quad 0x3fccd44980000000
+                    .quad 0x3fccf55810000000
+                    .quad 0x3fcd165300000000
+                    .quad 0x3fcd373a60000000
+                    .quad 0x3fcd580e60000000
+                    .quad 0x3fcd78cf00000000
+                    .quad 0x3fcd997c70000000
+                    .quad 0x3fcdba16a0000000
+                    .quad 0x3fcdda9dd0000000
+                    .quad 0x3fcdfb11f0000000
+                    .quad 0x3fce1b7330000000
+                    .quad 0x3fce3bc1a0000000
+                    .quad 0x3fce5bfd50000000
+                    .quad 0x3fce7c2660000000
+                    .quad 0x3fce9c3ce0000000
+                    .quad 0x3fcebc40e0000000
+                    .quad 0x3fcedc3280000000
+                    .quad 0x3fcefc11d0000000
+                    .quad 0x3fcf1bdee0000000
+                    .quad 0x3fcf3b99d0000000
+                    .quad 0x3fcf5b42a0000000
+                    .quad 0x3fcf7ad980000000
+                    .quad 0x3fcf9a5e70000000
+                    .quad 0x3fcfb9d190000000
+                    .quad 0x3fcfd932f0000000
+                    .quad 0x3fcff882a0000000
+                    .quad 0x3fd00be050000000
+                    .quad 0x3fd01b76a0000000
+                    .quad 0x3fd02b0430000000
+                    .quad 0x3fd03a8910000000
+                    .quad 0x3fd04a0540000000
+                    .quad 0x3fd05978e0000000
+                    .quad 0x3fd068e3f0000000
+                    .quad 0x3fd0784670000000
+                    .quad 0x3fd087a080000000
+                    .quad 0x3fd096f210000000
+                    .quad 0x3fd0a63b30000000
+                    .quad 0x3fd0b57bf0000000
+                    .quad 0x3fd0c4b450000000
+                    .quad 0x3fd0d3e460000000
+                    .quad 0x3fd0e30c30000000
+                    .quad 0x3fd0f22bc0000000
+                    .quad 0x3fd1014310000000
+                    .quad 0x3fd1105240000000
+                    .quad 0x3fd11f5940000000
+                    .quad 0x3fd12e5830000000
+                    .quad 0x3fd13d4f00000000
+                    .quad 0x3fd14c3dd0000000
+                    .quad 0x3fd15b24a0000000
+                    .quad 0x3fd16a0370000000
+                    .quad 0x3fd178da50000000
+                    .quad 0x3fd187a940000000
+                    .quad 0x3fd1967060000000
+                    .quad 0x3fd1a52fa0000000
+                    .quad 0x3fd1b3e710000000
+                    .quad 0x3fd1c296c0000000
+                    .quad 0x3fd1d13eb0000000
+                    .quad 0x3fd1dfdef0000000
+                    .quad 0x3fd1ee7770000000
+                    .quad 0x3fd1fd0860000000
+                    .quad 0x3fd20b91a0000000
+                    .quad 0x3fd21a1350000000
+                    .quad 0x3fd2288d70000000
+                    .quad 0x3fd2370010000000
+                    .quad 0x3fd2456b30000000
+                    .quad 0x3fd253ced0000000
+                    .quad 0x3fd2622b00000000
+                    .quad 0x3fd2707fd0000000
+                    .quad 0x3fd27ecd40000000
+                    .quad 0x3fd28d1360000000
+                    .quad 0x3fd29b5220000000
+                    .quad 0x3fd2a989a0000000
+                    .quad 0x3fd2b7b9e0000000
+                    .quad 0x3fd2c5e2e0000000
+                    .quad 0x3fd2d404b0000000
+                    .quad 0x3fd2e21f50000000
+                    .quad 0x3fd2f032c0000000
+                    .quad 0x3fd2fe3f20000000
+                    .quad 0x3fd30c4470000000
+                    .quad 0x3fd31a42b0000000
+                    .quad 0x3fd32839e0000000
+                    .quad 0x3fd3362a10000000
+                    .quad 0x3fd3441350000000
+
+.align 16
+.L__log_256_tail:
+                    .quad 0x0000000000000000
+                    .quad 0x3db20abc22b2208f
+                    .quad 0x3db10f69332e0dd4
+                    .quad 0x3dce950de87ed257
+                    .quad 0x3dd3f3443b626d69
+                    .quad 0x3df45aeaa5363e57
+                    .quad 0x3dc443683ce1bf0b
+                    .quad 0x3df989cd60c6a511
+                    .quad 0x3dfd626f201f2e9f
+                    .quad 0x3de94f8bb8dabdcd
+                    .quad 0x3e0088d8ef423015
+                    .quad 0x3e080413a62b79ad
+                    .quad 0x3e059717c0eed3c4
+                    .quad 0x3dad4a77add44902
+                    .quad 0x3e0e763ff037300e
+                    .quad 0x3de162d74706f6c3
+                    .quad 0x3e0601cc1f4dbc14
+                    .quad 0x3deaf3e051f6e5bf
+                    .quad 0x3e097a0b1e1af3eb
+                    .quad 0x3dc0a38970c002c7
+                    .quad 0x3e102e000057c751
+                    .quad 0x3e155b00eecd6e0e
+                    .quad 0x3ddf86297003b5af
+                    .quad 0x3e1057b9b336a36d
+                    .quad 0x3e134bc84a06ea4f
+                    .quad 0x3e1643da9ea1bcad
+                    .quad 0x3e1d66a7b4f7ea2a
+                    .quad 0x3df6b2e038f7fcef
+                    .quad 0x3df3e954c670f088
+                    .quad 0x3e047209093acab3
+                    .quad 0x3e1d708fe7275da7
+                    .quad 0x3e1fdf9e7771b9e7
+                    .quad 0x3e0827bfa70a0660
+                    .quad 0x3e1601cc1f4dbc14
+                    .quad 0x3e0637f6106a5e5b
+                    .quad 0x3e126a13f17c624b
+                    .quad 0x3e093eb2ce80623a
+                    .quad 0x3e1430d1e91594de
+                    .quad 0x3e1d6b10108fa031
+                    .quad 0x3e16879c0bbaf241
+                    .quad 0x3dff08015ea6bc2b
+                    .quad 0x3e29b63dcdc6676c
+                    .quad 0x3e2b022cbcc4ab2c
+                    .quad 0x3df917d07ddd6544
+                    .quad 0x3e1540605703379e
+                    .quad 0x3e0cd18b947a1b60
+                    .quad 0x3e17ad65277ca97e
+                    .quad 0x3e11884dc59f5fa9
+                    .quad 0x3e1711c46006d082
+                    .quad 0x3e2f092e3c3108f8
+                    .quad 0x3e1714c5e32be13a
+                    .quad 0x3e26bba7fd734f9a
+                    .quad 0x3dfdf48fb5e08483
+                    .quad 0x3e232f9bc74d0b95
+                    .quad 0x3df973e848790c13
+                    .quad 0x3e1eccbc08c6586e
+                    .quad 0x3e2115e9f9524a98
+                    .quad 0x3e2f1740593131b8
+                    .quad 0x3e1bcf8b25643835
+                    .quad 0x3e1f5fa81d8bed80
+                    .quad 0x3e244a4df929d9e4
+                    .quad 0x3e129820d8220c94
+                    .quad 0x3e2a0b489304e309
+                    .quad 0x3e1f4d56aba665fe
+                    .quad 0x3e210c9019365163
+                    .quad 0x3df80f78fe592736
+                    .quad 0x3e10528825c81cca
+                    .quad 0x3de095537d6d746a
+                    .quad 0x3e1827bfa70a0660
+                    .quad 0x3e06b0a8ec45933c
+                    .quad 0x3e105af81bf5dba9
+                    .quad 0x3e17e2fa2655d515
+                    .quad 0x3e0d59ecbfaee4bf
+                    .quad 0x3e1d8b2fda683fa3
+                    .quad 0x3e24b8ddfd3a3737
+                    .quad 0x3e13827e61ae1204
+                    .quad 0x3e2c8c7b49e90f9f
+                    .quad 0x3e29eaf01597591d
+                    .quad 0x3e19aaa66e317b36
+                    .quad 0x3e2e725609720655
+                    .quad 0x3e261c33fc7aac54
+                    .quad 0x3e29662bcf61a252
+                    .quad 0x3e1843c811c42730
+                    .quad 0x3e2064bb0b5acb36
+                    .quad 0x3e0a340c842701a4
+                    .quad 0x3e1a8e55b58f79d6
+                    .quad 0x3de92d219c5e9d9a
+                    .quad 0x3e3f63e60d7ffd6a
+                    .quad 0x3e2e9b0ed9516314
+                    .quad 0x3e2923901962350c
+                    .quad 0x3e326f8838785e81
+                    .quad 0x3e3b5b6a4caba6af
+                    .quad 0x3df0226adc8e761c
+                    .quad 0x3e3c4ad7313a1aed
+                    .quad 0x3e1564e87c738d17
+                    .quad 0x3e338fecf18a6618
+                    .quad 0x3e3d929ef5777666
+                    .quad 0x3e39483bf08da0b8
+                    .quad 0x3e3bdd0eeeaa5826
+                    .quad 0x3e39c4dd590237ba
+                    .quad 0x3e1af3e9e0ebcac7
+                    .quad 0x3e35ce5382270dac
+                    .quad 0x3e394f74532ab9ba
+                    .quad 0x3e07342795888654
+                    .quad 0x3e0c5a000be34bf0
+                    .quad 0x3e2711c46006d082
+                    .quad 0x3e250025b4ed8cf8
+                    .quad 0x3e2ed18bcef2d2a0
+                    .quad 0x3e21282e0c0a7554
+                    .quad 0x3e0d70f33359a7ca
+                    .quad 0x3e2b7f7e13a84025
+                    .quad 0x3e33306ec321891e
+                    .quad 0x3e3fc7f8038b7550
+                    .quad 0x3e3eb0358cd71d64
+                    .quad 0x3e3a76c822859474
+                    .quad 0x3e3d0ec652de86e3
+                    .quad 0x3e2fa4cce08658af
+                    .quad 0x3e3b84a2d2c00a9e
+                    .quad 0x3e20a5b0f2c25bd1
+                    .quad 0x3e3dd660225bf699
+                    .quad 0x3e08b10f859bf037
+                    .quad 0x3e3e8823b590cbe1
+                    .quad 0x3e361311f31e96f6
+                    .quad 0x3e2e1f875ca20f9a
+                    .quad 0x3e2c95724939b9a5
+                    .quad 0x3e3805957a3e58e2
+                    .quad 0x3e2ff126ea9f0334
+                    .quad 0x3e3953f5598e5609
+                    .quad 0x3e36c16ff856c448
+                    .quad 0x3e24cb220ff261f4
+                    .quad 0x3e35e120d53d53a2
+                    .quad 0x3e3a527f6189f256
+                    .quad 0x3e3856fcffd49c0f
+                    .quad 0x3e300c2e8228d7da
+                    .quad 0x3df113d09444dfe0
+                    .quad 0x3e2510630eea59a6
+                    .quad 0x3e262e780f32d711
+                    .quad 0x3ded3ed91a10f8cf
+                    .quad 0x3e23654a7e4bcd85
+                    .quad 0x3e055b784980ad21
+                    .quad 0x3e212f2dd4b16e64
+                    .quad 0x3e37c4add939f50c
+                    .quad 0x3e281784627180fc
+                    .quad 0x3dea5162c7e14961
+                    .quad 0x3e310c9019365163
+                    .quad 0x3e373c4d2ba17688
+                    .quad 0x3e2ae8a5e0e93d81
+                    .quad 0x3e2ab0c6f01621af
+                    .quad 0x3e301e8b74dd5b66
+                    .quad 0x3e2d206fecbb5494
+                    .quad 0x3df0b48b724fcc00
+                    .quad 0x3e3f831f0b61e229
+                    .quad 0x3df81a97c407bcaf
+                    .quad 0x3e3e286c1ccbb7aa
+                    .quad 0x3e28630b49220a93
+                    .quad 0x3dff0b15c1a22c5c
+                    .quad 0x3e355445e71c0946
+                    .quad 0x3e3be630f8066d85
+                    .quad 0x3e2599dff0d96c39
+                    .quad 0x3e36cc85b18fb081
+                    .quad 0x3e34476d001ea8c8
+                    .quad 0x3e373f889e16d31f
+                    .quad 0x3e3357100d792a87
+                    .quad 0x3e3bd179ae6101f6
+                    .quad 0x3e0ca31056c3f6e2
+                    .quad 0x3e3d2870629c08fb
+                    .quad 0x3e3aba3880d2673f
+                    .quad 0x3e2c3633cb297da6
+                    .quad 0x3e21843899efea02
+                    .quad 0x3e3bccc99d2008e6
+                    .quad 0x3e38000544bdd350
+                    .quad 0x3e2b91c226606ae1
+                    .quad 0x3e2a7adf26b62bdf
+                    .quad 0x3e18764fc8826ec9
+                    .quad 0x3e1f4f3de50f68f0
+                    .quad 0x3df760ca757995e3
+                    .quad 0x3dfc667ed3805147
+                    .quad 0x3e3733f6196adf6f
+                    .quad 0x3e2fb710f33e836b
+                    .quad 0x3e39886eba641013
+                    .quad 0x3dfb5368d0af8c1a
+                    .quad 0x3e358c691b8d2971
+                    .quad 0x3dfe9465226d08fb
+                    .quad 0x3e33587e063f0097
+                    .quad 0x3e3618e702129f18
+                    .quad 0x3e361c33fc7aac54
+                    .quad 0x3e3f07a68408604a
+                    .quad 0x3e3c34bfe4945421
+                    .quad 0x3e38b1f00e41300b
+                    .quad 0x3e3f434284d61b63
+                    .quad 0x3e3a63095e397436
+                    .quad 0x3e34428656b919de
+                    .quad 0x3e36ca9201b2d9a6
+                    .quad 0x3e2738823a2a931c
+                    .quad 0x3e3c11880e179230
+                    .quad 0x3e313ddc8d6d52fe
+                    .quad 0x3e33eed58922e917
+                    .quad 0x3e295992846bdd50
+                    .quad 0x3e0ddb4d5f2e278b
+                    .quad 0x3df1a5f12a0635c4
+                    .quad 0x3e4642f0882c3c34
+                    .quad 0x3e2aee9ba7f6475e
+                    .quad 0x3e264b7f834a60e4
+                    .quad 0x3e290d42e243792e
+                    .quad 0x3e4c272008134f01
+                    .quad 0x3e4a782e16d6cf5b
+                    .quad 0x3e44505c79da6648
+                    .quad 0x3e4ca9d4ea4dcd21
+                    .quad 0x3e297d3d627cd5bc
+                    .quad 0x3e20b15cf9bcaa13
+                    .quad 0x3e315b2063cf76dd
+                    .quad 0x3e2983e6f3aa2748
+                    .quad 0x3e3f4c64f4ffe994
+                    .quad 0x3e46beba7ce85a0f
+                    .quad 0x3e3b9c69fd4ea6b8
+                    .quad 0x3e2b6aa5835fa4ab
+                    .quad 0x3e43ccc3790fedd1
+                    .quad 0x3e29c04cc4404fe0
+                    .quad 0x3e40734b7a75d89d
+                    .quad 0x3e1b4404c4e01612
+                    .quad 0x3e40c565c2ce4894
+                    .quad 0x3e33c71441d935cd
+                    .quad 0x3d72a492556b3b4e
+                    .quad 0x3e20fa090341dc43
+                    .quad 0x3e2e8f7009e3d9f4
+                    .quad 0x3e4b1bf68b048a45
+                    .quad 0x3e3eee52dffaa956
+                    .quad 0x3e456b0900e465bd
+                    .quad 0x3e4d929ef5777666
+                    .quad 0x3e486ea28637e260
+                    .quad 0x3e4665aff10ca2f0
+                    .quad 0x3e2f11fdaf48ec74
+                    .quad 0x3e4cbe1b86a4d1c7
+                    .quad 0x3e25b05bfea87665
+                    .quad 0x3e41cec20a1a4a1d
+                    .quad 0x3e41cd5f0a409b9f
+                    .quad 0x3e453656c8265070
+                    .quad 0x3e377ed835282260
+                    .quad 0x3e2417bc3040b9d2
+                    .quad 0x3e408eef7b79eff2
+                    .quad 0x3e4dc76f39dc57e9
+                    .quad 0x3e4c0493a70cf457
+                    .quad 0x3e4a83d6cea5a60c
+                    .quad 0x3e30d6700dc557ba
+                    .quad 0x3e44c96c12e8bd0a
+                    .quad 0x3e3d2c1993e32315
+                    .quad 0x3e22c721135f8242
+                    .quad 0x3e279a3e4dda747d
+                    .quad 0x3dfcf89f6941a72b
+                    .quad 0x3e2149a702f10831
+                    .quad 0x3e4ead4b7c8175db
+                    .quad 0x3e4e6930fe63e70a
+                    .quad 0x3e41e106bed9ee2f
+                    .quad 0x3e2d682b82f11c92
+                    .quad 0x3e3a07f188dba47c
+                    .quad 0x3e40f9342dc172f6
+                    .quad 0x3e03ef3fde623e25
+
+.align 16
+.L__log_F_inv:
+                    .quad 0x4000000000000000
+                    .quad 0x3fffe01fe01fe020
+                    .quad 0x3fffc07f01fc07f0
+                    .quad 0x3fffa11caa01fa12
+                    .quad 0x3fff81f81f81f820
+                    .quad 0x3fff6310aca0dbb5
+                    .quad 0x3fff44659e4a4271
+                    .quad 0x3fff25f644230ab5
+                    .quad 0x3fff07c1f07c1f08
+                    .quad 0x3ffee9c7f8458e02
+                    .quad 0x3ffecc07b301ecc0
+                    .quad 0x3ffeae807aba01eb
+                    .quad 0x3ffe9131abf0b767
+                    .quad 0x3ffe741aa59750e4
+                    .quad 0x3ffe573ac901e574
+                    .quad 0x3ffe3a9179dc1a73
+                    .quad 0x3ffe1e1e1e1e1e1e
+                    .quad 0x3ffe01e01e01e01e
+                    .quad 0x3ffde5d6e3f8868a
+                    .quad 0x3ffdca01dca01dca
+                    .quad 0x3ffdae6076b981db
+                    .quad 0x3ffd92f2231e7f8a
+                    .quad 0x3ffd77b654b82c34
+                    .quad 0x3ffd5cac807572b2
+                    .quad 0x3ffd41d41d41d41d
+                    .quad 0x3ffd272ca3fc5b1a
+                    .quad 0x3ffd0cb58f6ec074
+                    .quad 0x3ffcf26e5c44bfc6
+                    .quad 0x3ffcd85689039b0b
+                    .quad 0x3ffcbe6d9601cbe7
+                    .quad 0x3ffca4b3055ee191
+                    .quad 0x3ffc8b265afb8a42
+                    .quad 0x3ffc71c71c71c71c
+                    .quad 0x3ffc5894d10d4986
+                    .quad 0x3ffc3f8f01c3f8f0
+                    .quad 0x3ffc26b5392ea01c
+                    .quad 0x3ffc0e070381c0e0
+                    .quad 0x3ffbf583ee868d8b
+                    .quad 0x3ffbdd2b899406f7
+                    .quad 0x3ffbc4fd65883e7b
+                    .quad 0x3ffbacf914c1bad0
+                    .quad 0x3ffb951e2b18ff23
+                    .quad 0x3ffb7d6c3dda338b
+                    .quad 0x3ffb65e2e3beee05
+                    .quad 0x3ffb4e81b4e81b4f
+                    .quad 0x3ffb37484ad806ce
+                    .quad 0x3ffb2036406c80d9
+                    .quad 0x3ffb094b31d922a4
+                    .quad 0x3ffaf286bca1af28
+                    .quad 0x3ffadbe87f94905e
+                    .quad 0x3ffac5701ac5701b
+                    .quad 0x3ffaaf1d2f87ebfd
+                    .quad 0x3ffa98ef606a63be
+                    .quad 0x3ffa82e65130e159
+                    .quad 0x3ffa6d01a6d01a6d
+                    .quad 0x3ffa574107688a4a
+                    .quad 0x3ffa41a41a41a41a
+                    .quad 0x3ffa2c2a87c51ca0
+                    .quad 0x3ffa16d3f97a4b02
+                    .quad 0x3ffa01a01a01a01a
+                    .quad 0x3ff9ec8e951033d9
+                    .quad 0x3ff9d79f176b682d
+                    .quad 0x3ff9c2d14ee4a102
+                    .quad 0x3ff9ae24ea5510da
+                    .quad 0x3ff999999999999a
+                    .quad 0x3ff9852f0d8ec0ff
+                    .quad 0x3ff970e4f80cb872
+                    .quad 0x3ff95cbb0be377ae
+                    .quad 0x3ff948b0fcd6e9e0
+                    .quad 0x3ff934c67f9b2ce6
+                    .quad 0x3ff920fb49d0e229
+                    .quad 0x3ff90d4f120190d5
+                    .quad 0x3ff8f9c18f9c18fa
+                    .quad 0x3ff8e6527af1373f
+                    .quad 0x3ff8d3018d3018d3
+                    .quad 0x3ff8bfce8062ff3a
+                    .quad 0x3ff8acb90f6bf3aa
+                    .quad 0x3ff899c0f601899c
+                    .quad 0x3ff886e5f0abb04a
+                    .quad 0x3ff87427bcc092b9
+                    .quad 0x3ff8618618618618
+                    .quad 0x3ff84f00c2780614
+                    .quad 0x3ff83c977ab2bedd
+                    .quad 0x3ff82a4a0182a4a0
+                    .quad 0x3ff8181818181818
+                    .quad 0x3ff8060180601806
+                    .quad 0x3ff7f405fd017f40
+                    .quad 0x3ff7e225515a4f1d
+                    .quad 0x3ff7d05f417d05f4
+                    .quad 0x3ff7beb3922e017c
+                    .quad 0x3ff7ad2208e0ecc3
+                    .quad 0x3ff79baa6bb6398b
+                    .quad 0x3ff78a4c8178a4c8
+                    .quad 0x3ff77908119ac60d
+                    .quad 0x3ff767dce434a9b1
+                    .quad 0x3ff756cac201756d
+                    .quad 0x3ff745d1745d1746
+                    .quad 0x3ff734f0c541fe8d
+                    .quad 0x3ff724287f46debc
+                    .quad 0x3ff713786d9c7c09
+                    .quad 0x3ff702e05c0b8170
+                    .quad 0x3ff6f26016f26017
+                    .quad 0x3ff6e1f76b4337c7
+                    .quad 0x3ff6d1a62681c861
+                    .quad 0x3ff6c16c16c16c17
+                    .quad 0x3ff6b1490aa31a3d
+                    .quad 0x3ff6a13cd1537290
+                    .quad 0x3ff691473a88d0c0
+                    .quad 0x3ff6816816816817
+                    .quad 0x3ff6719f3601671a
+                    .quad 0x3ff661ec6a5122f9
+                    .quad 0x3ff6524f853b4aa3
+                    .quad 0x3ff642c8590b2164
+                    .quad 0x3ff63356b88ac0de
+                    .quad 0x3ff623fa77016240
+                    .quad 0x3ff614b36831ae94
+                    .quad 0x3ff6058160581606
+                    .quad 0x3ff5f66434292dfc
+                    .quad 0x3ff5e75bb8d015e7
+                    .quad 0x3ff5d867c3ece2a5
+                    .quad 0x3ff5c9882b931057
+                    .quad 0x3ff5babcc647fa91
+                    .quad 0x3ff5ac056b015ac0
+                    .quad 0x3ff59d61f123ccaa
+                    .quad 0x3ff58ed2308158ed
+                    .quad 0x3ff5805601580560
+                    .quad 0x3ff571ed3c506b3a
+                    .quad 0x3ff56397ba7c52e2
+                    .quad 0x3ff5555555555555
+                    .quad 0x3ff54725e6bb82fe
+                    .quad 0x3ff5390948f40feb
+                    .quad 0x3ff52aff56a8054b
+                    .quad 0x3ff51d07eae2f815
+                    .quad 0x3ff50f22e111c4c5
+                    .quad 0x3ff5015015015015
+                    .quad 0x3ff4f38f62dd4c9b
+                    .quad 0x3ff4e5e0a72f0539
+                    .quad 0x3ff4d843bedc2c4c
+                    .quad 0x3ff4cab88725af6e
+                    .quad 0x3ff4bd3edda68fe1
+                    .quad 0x3ff4afd6a052bf5b
+                    .quad 0x3ff4a27fad76014a
+                    .quad 0x3ff49539e3b2d067
+                    .quad 0x3ff4880522014880
+                    .quad 0x3ff47ae147ae147b
+                    .quad 0x3ff46dce34596066
+                    .quad 0x3ff460cbc7f5cf9a
+                    .quad 0x3ff453d9e2c776ca
+                    .quad 0x3ff446f86562d9fb
+                    .quad 0x3ff43a2730abee4d
+                    .quad 0x3ff42d6625d51f87
+                    .quad 0x3ff420b5265e5951
+                    .quad 0x3ff4141414141414
+                    .quad 0x3ff40782d10e6566
+                    .quad 0x3ff3fb013fb013fb
+                    .quad 0x3ff3ee8f42a5af07
+                    .quad 0x3ff3e22cbce4a902
+                    .quad 0x3ff3d5d991aa75c6
+                    .quad 0x3ff3c995a47babe7
+                    .quad 0x3ff3bd60d9232955
+                    .quad 0x3ff3b13b13b13b14
+                    .quad 0x3ff3a524387ac822
+                    .quad 0x3ff3991c2c187f63
+                    .quad 0x3ff38d22d366088e
+                    .quad 0x3ff3813813813814
+                    .quad 0x3ff3755bd1c945ee
+                    .quad 0x3ff3698df3de0748
+                    .quad 0x3ff35dce5f9f2af8
+                    .quad 0x3ff3521cfb2b78c1
+                    .quad 0x3ff34679ace01346
+                    .quad 0x3ff33ae45b57bcb2
+                    .quad 0x3ff32f5ced6a1dfa
+                    .quad 0x3ff323e34a2b10bf
+                    .quad 0x3ff3187758e9ebb6
+                    .quad 0x3ff30d190130d190
+                    .quad 0x3ff301c82ac40260
+                    .quad 0x3ff2f684bda12f68
+                    .quad 0x3ff2eb4ea1fed14b
+                    .quad 0x3ff2e025c04b8097
+                    .quad 0x3ff2d50a012d50a0
+                    .quad 0x3ff2c9fb4d812ca0
+                    .quad 0x3ff2bef98e5a3711
+                    .quad 0x3ff2b404ad012b40
+                    .quad 0x3ff2a91c92f3c105
+                    .quad 0x3ff29e4129e4129e
+                    .quad 0x3ff293725bb804a5
+                    .quad 0x3ff288b01288b013
+                    .quad 0x3ff27dfa38a1ce4d
+                    .quad 0x3ff27350b8812735
+                    .quad 0x3ff268b37cd60127
+                    .quad 0x3ff25e22708092f1
+                    .quad 0x3ff2539d7e9177b2
+                    .quad 0x3ff2492492492492
+                    .quad 0x3ff23eb79717605b
+                    .quad 0x3ff23456789abcdf
+                    .quad 0x3ff22a0122a0122a
+                    .quad 0x3ff21fb78121fb78
+                    .quad 0x3ff21579804855e6
+                    .quad 0x3ff20b470c67c0d9
+                    .quad 0x3ff2012012012012
+                    .quad 0x3ff1f7047dc11f70
+                    .quad 0x3ff1ecf43c7fb84c
+                    .quad 0x3ff1e2ef3b3fb874
+                    .quad 0x3ff1d8f5672e4abd
+                    .quad 0x3ff1cf06ada2811d
+                    .quad 0x3ff1c522fc1ce059
+                    .quad 0x3ff1bb4a4046ed29
+                    .quad 0x3ff1b17c67f2bae3
+                    .quad 0x3ff1a7b9611a7b96
+                    .quad 0x3ff19e0119e0119e
+                    .quad 0x3ff19453808ca29c
+                    .quad 0x3ff18ab083902bdb
+                    .quad 0x3ff1811811811812
+                    .quad 0x3ff1778a191bd684
+                    .quad 0x3ff16e0689427379
+                    .quad 0x3ff1648d50fc3201
+                    .quad 0x3ff15b1e5f75270d
+                    .quad 0x3ff151b9a3fdd5c9
+                    .quad 0x3ff1485f0e0acd3b
+                    .quad 0x3ff13f0e8d344724
+                    .quad 0x3ff135c81135c811
+                    .quad 0x3ff12c8b89edc0ac
+                    .quad 0x3ff12358e75d3033
+                    .quad 0x3ff11a3019a74826
+                    .quad 0x3ff1111111111111
+                    .quad 0x3ff107fbbe011080
+                    .quad 0x3ff0fef010fef011
+                    .quad 0x3ff0f5edfab325a2
+                    .quad 0x3ff0ecf56be69c90
+                    .quad 0x3ff0e40655826011
+                    .quad 0x3ff0db20a88f4696
+                    .quad 0x3ff0d24456359e3a
+                    .quad 0x3ff0c9714fbcda3b
+                    .quad 0x3ff0c0a7868b4171
+                    .quad 0x3ff0b7e6ec259dc8
+                    .quad 0x3ff0af2f722eecb5
+                    .quad 0x3ff0a6810a6810a7
+                    .quad 0x3ff09ddba6af8360
+                    .quad 0x3ff0953f39010954
+                    .quad 0x3ff08cabb37565e2
+                    .quad 0x3ff0842108421084
+                    .quad 0x3ff07b9f29b8eae2
+                    .quad 0x3ff073260a47f7c6
+                    .quad 0x3ff06ab59c7912fb
+                    .quad 0x3ff0624dd2f1a9fc
+                    .quad 0x3ff059eea0727586
+                    .quad 0x3ff05197f7d73404
+                    .quad 0x3ff04949cc1664c5
+                    .quad 0x3ff0410410410410
+                    .quad 0x3ff038c6b78247fc
+                    .quad 0x3ff03091b51f5e1a
+                    .quad 0x3ff02864fc7729e9
+                    .quad 0x3ff0204081020408
+                    .quad 0x3ff0182436517a37
+                    .quad 0x3ff0101010101010
+                    .quad 0x3ff0080402010080
+                    .quad 0x3ff0000000000000
+                    .quad 0x0000000000000000
+
+
diff --git a/src/gas/log10f.S b/src/gas/log10f.S
new file mode 100644
index 0000000..eb89c6c
--- /dev/null
+++ b/src/gas/log10f.S
@@ -0,0 +1,745 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#
+# log10f.S
+#
+# An implementation of the log10f libm function.
+#
+# Prototype:
+#
+#     float log10f(float x);
+#
+
+#
+#   Algorithm:
+#       Similar to one presnted in log.S
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(log10f)
+#define fname_special _log10f_special@PLT
+
+
+# local variable storage offsets
+.equ    p_temp, 0x0
+.equ    stack_size, 0x18
+
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+
+    sub         $stack_size, %rsp
+
+    # compute exponent part
+    xor         %eax, %eax
+    movdqa      %xmm0, %xmm3
+    movss       %xmm0, %xmm4
+    psrld       $23, %xmm3
+    movd        %xmm0, %eax
+    psubd       .L__mask_127(%rip), %xmm3
+    movdqa      %xmm0, %xmm2
+    cvtdq2ps    %xmm3, %xmm5 # xexp
+
+    #  NaN or inf
+    movdqa      %xmm0, %xmm1
+    andps       .L__real_inf(%rip), %xmm1
+    comiss      .L__real_inf(%rip), %xmm1
+    je          .L__x_is_inf_or_nan
+
+    # check for negative numbers or zero
+    xorps       %xmm1, %xmm1
+    comiss      %xmm1, %xmm0
+    jbe         .L__x_is_zero_or_neg
+
+    pand        .L__real_mant(%rip), %xmm2
+    subss       .L__real_one(%rip), %xmm4
+
+    comiss      .L__real_neg127(%rip), %xmm5
+    je          .L__denormal_adjust
+
+.L__continue_common:
+
+    # compute index into the log tables
+    mov         %eax, %r9d
+    and         .L__mask_mant_all7(%rip), %eax
+    and         .L__mask_mant8(%rip), %r9d
+    shl         $1, %r9d
+    add         %r9d, %eax
+    mov         %eax, p_temp(%rsp)
+
+    # near one codepath
+    andps       .L__real_notsign(%rip), %xmm4
+    comiss      .L__real_threshold(%rip), %xmm4
+    jb          .L__near_one
+
+    # F, Y
+    movss       p_temp(%rsp), %xmm1
+    shr         $16, %eax
+    por         .L__real_half(%rip), %xmm2
+    por         .L__real_half(%rip), %xmm1
+    lea         .L__log_F_inv(%rip), %r9
+
+    # f = F - Y, r = f * inv
+    subss       %xmm2, %xmm1
+    mulss       (%r9,%rax,4), %xmm1
+
+    movss       %xmm1, %xmm2
+    movss       %xmm1, %xmm0
+
+    # poly
+    mulss       .L__real_1_over_3(%rip), %xmm2
+    mulss       %xmm1, %xmm0
+    addss       .L__real_1_over_2(%rip), %xmm2
+    movss       .L__real_log10_2_tail(%rip), %xmm3
+
+    lea         .L__log_128_tail(%rip), %r9
+    lea         .L__log_128_lead(%rip), %r10
+
+    mulss       %xmm0, %xmm2
+    mulss       %xmm5, %xmm3
+    addss       %xmm2, %xmm1
+
+    mulss       .L__real_log10_e(%rip), %xmm1
+
+    # m*log(10) + log10(G) - poly
+    movss       .L__real_log10_2_lead(%rip), %xmm0
+    subss       %xmm1, %xmm3 # z2
+    mulss       %xmm5, %xmm0
+    addss       (%r9,%rax,4), %xmm3
+    addss       (%r10,%rax,4), %xmm0
+
+    addss       %xmm3, %xmm0
+
+    add         $stack_size, %rsp
+    ret
+
+.p2align 4,,15
+.L__near_one:
+    # r = x - 1.0#
+    movss       .L__real_two(%rip), %xmm2
+    subss       .L__real_one(%rip), %xmm0
+
+    # u = r / (2.0 + r)
+    addss       %xmm0, %xmm2
+    movss       %xmm0, %xmm1
+    divss       %xmm2, %xmm1 # u
+
+    # correction = r * u
+    movss       %xmm0, %xmm4
+    mulss       %xmm1, %xmm4
+
+    # u = u + u#
+    addss       %xmm1, %xmm1
+    movss       %xmm1, %xmm2
+    mulss       %xmm2, %xmm2 # v = u^2
+
+    # r2 = (u * v * (ca_1 + v * ca_2) - correction)
+    movss       %xmm1, %xmm3
+    mulss       %xmm2, %xmm3 # u^3
+    mulss       .L__real_ca2(%rip), %xmm2 # Bu^2
+    addss       .L__real_ca1(%rip), %xmm2 # +A
+    mulss       %xmm3, %xmm2
+    subss       %xmm4, %xmm2 # -correction
+
+    movdqa      %xmm0, %xmm5
+    pand        .L__mask_lower(%rip), %xmm5
+    subss       %xmm5, %xmm0
+    addss       %xmm0, %xmm2
+
+    movss       %xmm5, %xmm0
+    movss       %xmm2, %xmm1
+
+    mulss       .L__real_log10_e_tail(%rip), %xmm2
+    mulss       .L__real_log10_e_tail(%rip), %xmm0
+    mulss       .L__real_log10_e_lead(%rip), %xmm1
+    mulss       .L__real_log10_e_lead(%rip), %xmm5
+
+    addss       %xmm2, %xmm0
+    addss       %xmm1, %xmm0
+    addss       %xmm5, %xmm0
+
+    add         $stack_size, %rsp
+    ret
+
+.L__denormal_adjust:
+    por         .L__real_one(%rip), %xmm2
+    subss       .L__real_one(%rip), %xmm2
+    movdqa      %xmm2, %xmm5
+    pand        .L__real_mant(%rip), %xmm2
+    movd        %xmm2, %eax
+    psrld       $23, %xmm5
+    psubd       .L__mask_253(%rip), %xmm5
+    cvtdq2ps    %xmm5, %xmm5
+    jmp         .L__continue_common
+
+.p2align 4,,15
+.L__x_is_zero_or_neg:
+    jne         .L__x_is_neg
+
+    movss       .L__real_ninf(%rip), %xmm1
+    mov         .L__flag_x_zero(%rip), %edi
+    call        fname_special
+    jmp         .L__finish
+
+.p2align 4,,15
+.L__x_is_neg:
+
+    movss       .L__real_nan(%rip), %xmm1
+    mov         .L__flag_x_neg(%rip), %edi
+    call        fname_special
+    jmp         .L__finish
+
+.p2align 4,,15
+.L__x_is_inf_or_nan:
+
+    cmp         .L__real_inf(%rip), %eax
+    je          .L__finish
+
+    cmp         .L__real_ninf(%rip), %eax
+    je          .L__x_is_neg
+
+    mov         .L__real_qnanbit(%rip), %r9d
+    and         %eax, %r9d
+    jnz         .L__finish
+
+    or          .L__real_qnanbit(%rip), %eax
+    movd        %eax, %xmm1
+    mov         .L__flag_x_nan(%rip), %edi
+    call        fname_special
+    jmp         .L__finish    
+
+.p2align 4,,15
+.L__finish:
+    add         $stack_size, %rsp
+    ret
+
+
+.data
+
+.align 16
+
+# these codes and the ones in the corresponding .c file have to match
+.L__flag_x_zero:        .long 00000001
+.L__flag_x_neg:         .long 00000002
+.L__flag_x_nan:         .long 00000003
+
+.align 16
+
+.L__real_one:           .quad 0x03f8000003f800000   # 1.0
+                        .quad 0x03f8000003f800000
+.L__real_two:           .quad 0x04000000040000000   # 1.0
+                        .quad 0x04000000040000000
+.L__real_ninf:          .quad 0x0ff800000ff800000   # -inf
+                        .quad 0x0ff800000ff800000
+.L__real_inf:           .quad 0x07f8000007f800000   # +inf
+                        .quad 0x07f8000007f800000
+.L__real_nan:           .quad 0x07fc000007fc00000   # NaN
+                        .quad 0x07fc000007fc00000
+.L__real_ef:            .quad 0x0402DF854402DF854   # float e
+                        .quad 0x0402DF854402DF854
+.L__real_neg_qnan:      .quad 0x0ffc00000ffc00000
+                        .quad 0x0ffc00000ffc00000
+
+.L__real_sign:          .quad 0x08000000080000000   # sign bit
+                        .quad 0x08000000080000000
+.L__real_notsign:       .quad 0x07ffFFFFF7ffFFFFF   # ^sign bit
+                        .quad 0x07ffFFFFF7ffFFFFF
+.L__real_qnanbit:       .quad 0x00040000000400000   # quiet nan bit
+                        .quad 0x00040000000400000
+.L__real_mant:          .quad 0x0007FFFFF007FFFFF   # mantissa bits
+                        .quad 0x0007FFFFF007FFFFF
+.L__mask_127:           .quad 0x00000007f0000007f   # 
+                        .quad 0x00000007f0000007f
+
+.L__mask_mant_all7:     .quad 0x00000000007f0000
+                        .quad 0x00000000007f0000
+.L__mask_mant8:         .quad 0x0000000000008000
+                        .quad 0x0000000000008000
+
+.L__real_ca1:           .quad 0x03DAAAAAB3DAAAAAB   # 8.33333333333317923934e-02
+                        .quad 0x03DAAAAAB3DAAAAAB
+.L__real_ca2:           .quad 0x03C4CCCCD3C4CCCCD   # 1.25000000037717509602e-02
+                        .quad 0x03C4CCCCD3C4CCCCD
+
+.L__real_log2_lead:     .quad 0x03F3170003F317000   # 0.693115234375
+                        .quad 0x03F3170003F317000
+.L__real_log2_tail:     .quad 0x03805FDF43805FDF4   # 0.000031946183
+                        .quad 0x03805FDF43805FDF4
+.L__real_half:          .quad 0x03f0000003f000000   # 1/2
+                        .quad 0x03f0000003f000000
+
+.L__real_log10_e_lead:  .quad 0x3EDE00003EDE0000    # log10e_lead  0.4335937500
+                        .quad 0x3EDE00003EDE0000
+.L__real_log10_e_tail:  .quad 0x3A37B1523A37B152    # log10e_tail  0.0007007319
+                        .quad 0x3A37B1523A37B152
+
+.L__real_log10_2_lead:  .quad 0x3e9a00003e9a0000
+                        .quad 0x0000000000000000
+.L__real_log10_2_tail:  .quad 0x39826a1339826a13
+                        .quad 0x0000000000000000
+.L__real_log10_e:       .quad 0x3ede5bd93ede5bd9
+                        .quad 0x0000000000000000
+
+.L__mask_lower:         .quad 0x0ffff0000ffff0000
+                        .quad 0x0ffff0000ffff0000
+
+.align 16
+
+.L__real_neg127:    .long 0x0c2fe0000
+                    .long 0
+                    .quad 0
+
+.L__mask_253:       .long 0x000000fd
+                    .long 0
+                    .quad 0
+
+.L__real_threshold: .long 0x3d800000
+                    .long 0
+                    .quad 0
+
+.L__mask_01:        .long 0x00000001
+                    .long 0
+                    .quad 0
+
+.L__mask_80:        .long 0x00000080
+                    .long 0
+                    .quad 0
+
+.L__real_3b800000:  .long 0x3b800000
+                    .long 0
+                    .quad 0
+
+.L__real_1_over_3:  .long 0x3eaaaaab
+                    .long 0
+                    .quad 0
+
+.L__real_1_over_2:  .long 0x3f000000
+                    .long 0
+                    .quad 0
+
+.align 16
+.L__log_128_lead:
+                    .long 0x00000000
+                    .long 0x3b5d4000
+                    .long 0x3bdc8000
+                    .long 0x3c24c000
+                    .long 0x3c5ac000
+                    .long 0x3c884000
+                    .long 0x3ca2c000
+                    .long 0x3cbd4000
+                    .long 0x3cd78000
+                    .long 0x3cf1c000
+                    .long 0x3d05c000
+                    .long 0x3d128000
+                    .long 0x3d1f4000
+                    .long 0x3d2c0000
+                    .long 0x3d388000
+                    .long 0x3d450000
+                    .long 0x3d518000
+                    .long 0x3d5dc000
+                    .long 0x3d6a0000
+                    .long 0x3d760000
+                    .long 0x3d810000
+                    .long 0x3d870000
+                    .long 0x3d8d0000
+                    .long 0x3d92c000
+                    .long 0x3d98c000
+                    .long 0x3d9e8000
+                    .long 0x3da44000
+                    .long 0x3daa0000
+                    .long 0x3dafc000
+                    .long 0x3db58000
+                    .long 0x3dbb4000
+                    .long 0x3dc0c000
+                    .long 0x3dc64000
+                    .long 0x3dcc0000
+                    .long 0x3dd18000
+                    .long 0x3dd6c000
+                    .long 0x3ddc4000
+                    .long 0x3de1c000
+                    .long 0x3de70000
+                    .long 0x3dec8000
+                    .long 0x3df1c000
+                    .long 0x3df70000
+                    .long 0x3dfc4000
+                    .long 0x3e00c000
+                    .long 0x3e034000
+                    .long 0x3e05c000
+                    .long 0x3e088000
+                    .long 0x3e0b0000
+                    .long 0x3e0d8000
+                    .long 0x3e100000
+                    .long 0x3e128000
+                    .long 0x3e150000
+                    .long 0x3e178000
+                    .long 0x3e1a0000
+                    .long 0x3e1c8000
+                    .long 0x3e1ec000
+                    .long 0x3e214000
+                    .long 0x3e23c000
+                    .long 0x3e260000
+                    .long 0x3e288000
+                    .long 0x3e2ac000
+                    .long 0x3e2d4000
+                    .long 0x3e2f8000
+                    .long 0x3e31c000
+                    .long 0x3e344000
+                    .long 0x3e368000
+                    .long 0x3e38c000
+                    .long 0x3e3b0000
+                    .long 0x3e3d4000
+                    .long 0x3e3fc000
+                    .long 0x3e420000
+                    .long 0x3e440000
+                    .long 0x3e464000
+                    .long 0x3e488000
+                    .long 0x3e4ac000
+                    .long 0x3e4d0000
+                    .long 0x3e4f4000
+                    .long 0x3e514000
+                    .long 0x3e538000
+                    .long 0x3e55c000
+                    .long 0x3e57c000
+                    .long 0x3e5a0000
+                    .long 0x3e5c0000
+                    .long 0x3e5e4000
+                    .long 0x3e604000
+                    .long 0x3e624000
+                    .long 0x3e648000
+                    .long 0x3e668000
+                    .long 0x3e688000
+                    .long 0x3e6ac000
+                    .long 0x3e6cc000
+                    .long 0x3e6ec000
+                    .long 0x3e70c000
+                    .long 0x3e72c000
+                    .long 0x3e74c000
+                    .long 0x3e76c000
+                    .long 0x3e78c000
+                    .long 0x3e7ac000
+                    .long 0x3e7cc000
+                    .long 0x3e7ec000
+                    .long 0x3e804000
+                    .long 0x3e814000
+                    .long 0x3e824000
+                    .long 0x3e834000
+                    .long 0x3e840000
+                    .long 0x3e850000
+                    .long 0x3e860000
+                    .long 0x3e870000
+                    .long 0x3e880000
+                    .long 0x3e88c000
+                    .long 0x3e89c000
+                    .long 0x3e8ac000
+                    .long 0x3e8bc000
+                    .long 0x3e8c8000
+                    .long 0x3e8d8000
+                    .long 0x3e8e8000
+                    .long 0x3e8f4000
+                    .long 0x3e904000
+                    .long 0x3e914000
+                    .long 0x3e920000
+                    .long 0x3e930000
+                    .long 0x3e93c000
+                    .long 0x3e94c000
+                    .long 0x3e958000
+                    .long 0x3e968000
+                    .long 0x3e978000
+                    .long 0x3e984000
+                    .long 0x3e994000
+                    .long 0x3e9a0000
+
+.align 16
+.L__log_128_tail:
+                    .long 0x00000000
+                    .long 0x367a8e44
+                    .long 0x368ed49f
+                    .long 0x36c21451
+                    .long 0x375211d6
+                    .long 0x3720ea11
+                    .long 0x37e9eb59
+                    .long 0x37b87be7
+                    .long 0x37bf2560
+                    .long 0x33d597a0
+                    .long 0x37806a05
+                    .long 0x3820581f
+                    .long 0x38223334
+                    .long 0x378e3bac
+                    .long 0x3810684f
+                    .long 0x37feb7ae
+                    .long 0x36a9d609
+                    .long 0x37a68163
+                    .long 0x376a8b27
+                    .long 0x384c8fd6
+                    .long 0x3885183e
+                    .long 0x3874a760
+                    .long 0x380d1154
+                    .long 0x38ea42bd
+                    .long 0x384c1571
+                    .long 0x38ba66b8
+                    .long 0x38e7da3b
+                    .long 0x38eee632
+                    .long 0x38d00911
+                    .long 0x388bbede
+                    .long 0x378a0512
+                    .long 0x3894c7a0
+                    .long 0x38e30710
+                    .long 0x36db2829
+                    .long 0x3729d609
+                    .long 0x38fa0e82
+                    .long 0x38bc9a75
+                    .long 0x383a9297
+                    .long 0x38dc83c8
+                    .long 0x37eac335
+                    .long 0x38706ac3
+                    .long 0x389574c2
+                    .long 0x3892d068
+                    .long 0x38615032
+                    .long 0x3917acf4
+                    .long 0x3967a126
+                    .long 0x38217840
+                    .long 0x38b420ab
+                    .long 0x38f9c7b2
+                    .long 0x391103bd
+                    .long 0x39169a6b
+                    .long 0x390dd194
+                    .long 0x38eda471
+                    .long 0x38a38950
+                    .long 0x37f6844a
+                    .long 0x395e1cdb
+                    .long 0x390fcffc
+                    .long 0x38503e9d
+                    .long 0x394b00fd
+                    .long 0x38a9910a
+                    .long 0x39518a31
+                    .long 0x3882d2c2
+                    .long 0x392488e4
+                    .long 0x397b0aff
+                    .long 0x388a22d8
+                    .long 0x3902bd5e
+                    .long 0x39342f85
+                    .long 0x39598811
+                    .long 0x3972e6b1
+                    .long 0x34d53654
+                    .long 0x360ca25e
+                    .long 0x39785cc0
+                    .long 0x39630710
+                    .long 0x39424ed7
+                    .long 0x39165101
+                    .long 0x38be5421
+                    .long 0x37e7b0c0
+                    .long 0x394fd0c3
+                    .long 0x38efaaaa
+                    .long 0x37a8f566
+                    .long 0x3927c744
+                    .long 0x383fa4d5
+                    .long 0x392d9e39
+                    .long 0x3803feae
+                    .long 0x390a268c
+                    .long 0x39692b80
+                    .long 0x38789b4f
+                    .long 0x3909307d
+                    .long 0x394a601c
+                    .long 0x35e67edc
+                    .long 0x383e386d
+                    .long 0x38a7743d
+                    .long 0x38dccec3
+                    .long 0x38ff57e0
+                    .long 0x39079d8b
+                    .long 0x390651a6
+                    .long 0x38f7bad9
+                    .long 0x38d0ab82
+                    .long 0x38979e7d
+                    .long 0x381978ee
+                    .long 0x397816c8
+                    .long 0x39410cb2
+                    .long 0x39015384
+                    .long 0x3863fa28
+                    .long 0x39f41065
+                    .long 0x39c7668a
+                    .long 0x39968afa
+                    .long 0x39430db9
+                    .long 0x38a18cf3
+                    .long 0x39eb2907
+                    .long 0x39a9e10c
+                    .long 0x39492800
+                    .long 0x385a53d1
+                    .long 0x39ce0cf7
+                    .long 0x3979c7b2
+                    .long 0x389f5d99
+                    .long 0x39ceefcb
+                    .long 0x39646a39
+                    .long 0x380d7a9b
+                    .long 0x39ad6650
+                    .long 0x390ac3b8
+                    .long 0x39d9a9a8
+                    .long 0x39548a99
+                    .long 0x39f73c4b
+                    .long 0x3980960e
+                    .long 0x374b3d5a
+                    .long 0x39888f1e
+                    .long 0x37679a07
+                    .long 0x39826a13
+
+.align 16
+.L__log_F_inv:
+                    .long 0x40000000
+                    .long 0x3ffe03f8
+                    .long 0x3ffc0fc1
+                    .long 0x3ffa232d
+                    .long 0x3ff83e10
+                    .long 0x3ff6603e
+                    .long 0x3ff4898d
+                    .long 0x3ff2b9d6
+                    .long 0x3ff0f0f1
+                    .long 0x3fef2eb7
+                    .long 0x3fed7304
+                    .long 0x3febbdb3
+                    .long 0x3fea0ea1
+                    .long 0x3fe865ac
+                    .long 0x3fe6c2b4
+                    .long 0x3fe52598
+                    .long 0x3fe38e39
+                    .long 0x3fe1fc78
+                    .long 0x3fe07038
+                    .long 0x3fdee95c
+                    .long 0x3fdd67c9
+                    .long 0x3fdbeb62
+                    .long 0x3fda740e
+                    .long 0x3fd901b2
+                    .long 0x3fd79436
+                    .long 0x3fd62b81
+                    .long 0x3fd4c77b
+                    .long 0x3fd3680d
+                    .long 0x3fd20d21
+                    .long 0x3fd0b6a0
+                    .long 0x3fcf6475
+                    .long 0x3fce168a
+                    .long 0x3fcccccd
+                    .long 0x3fcb8728
+                    .long 0x3fca4588
+                    .long 0x3fc907da
+                    .long 0x3fc7ce0c
+                    .long 0x3fc6980c
+                    .long 0x3fc565c8
+                    .long 0x3fc43730
+                    .long 0x3fc30c31
+                    .long 0x3fc1e4bc
+                    .long 0x3fc0c0c1
+                    .long 0x3fbfa030
+                    .long 0x3fbe82fa
+                    .long 0x3fbd6910
+                    .long 0x3fbc5264
+                    .long 0x3fbb3ee7
+                    .long 0x3fba2e8c
+                    .long 0x3fb92144
+                    .long 0x3fb81703
+                    .long 0x3fb70fbb
+                    .long 0x3fb60b61
+                    .long 0x3fb509e7
+                    .long 0x3fb40b41
+                    .long 0x3fb30f63
+                    .long 0x3fb21643
+                    .long 0x3fb11fd4
+                    .long 0x3fb02c0b
+                    .long 0x3faf3ade
+                    .long 0x3fae4c41
+                    .long 0x3fad602b
+                    .long 0x3fac7692
+                    .long 0x3fab8f6a
+                    .long 0x3faaaaab
+                    .long 0x3fa9c84a
+                    .long 0x3fa8e83f
+                    .long 0x3fa80a81
+                    .long 0x3fa72f05
+                    .long 0x3fa655c4
+                    .long 0x3fa57eb5
+                    .long 0x3fa4a9cf
+                    .long 0x3fa3d70a
+                    .long 0x3fa3065e
+                    .long 0x3fa237c3
+                    .long 0x3fa16b31
+                    .long 0x3fa0a0a1
+                    .long 0x3f9fd80a
+                    .long 0x3f9f1166
+                    .long 0x3f9e4cad
+                    .long 0x3f9d89d9
+                    .long 0x3f9cc8e1
+                    .long 0x3f9c09c1
+                    .long 0x3f9b4c70
+                    .long 0x3f9a90e8
+                    .long 0x3f99d723
+                    .long 0x3f991f1a
+                    .long 0x3f9868c8
+                    .long 0x3f97b426
+                    .long 0x3f97012e
+                    .long 0x3f964fda
+                    .long 0x3f95a025
+                    .long 0x3f94f209
+                    .long 0x3f944581
+                    .long 0x3f939a86
+                    .long 0x3f92f114
+                    .long 0x3f924925
+                    .long 0x3f91a2b4
+                    .long 0x3f90fdbc
+                    .long 0x3f905a38
+                    .long 0x3f8fb824
+                    .long 0x3f8f177a
+                    .long 0x3f8e7835
+                    .long 0x3f8dda52
+                    .long 0x3f8d3dcb
+                    .long 0x3f8ca29c
+                    .long 0x3f8c08c1
+                    .long 0x3f8b7034
+                    .long 0x3f8ad8f3
+                    .long 0x3f8a42f8
+                    .long 0x3f89ae41
+                    .long 0x3f891ac7
+                    .long 0x3f888889
+                    .long 0x3f87f781
+                    .long 0x3f8767ab
+                    .long 0x3f86d905
+                    .long 0x3f864b8a
+                    .long 0x3f85bf37
+                    .long 0x3f853408
+                    .long 0x3f84a9fa
+                    .long 0x3f842108
+                    .long 0x3f839930
+                    .long 0x3f83126f
+                    .long 0x3f828cc0
+                    .long 0x3f820821
+                    .long 0x3f81848e
+                    .long 0x3f810204
+                    .long 0x3f808081
+                    .long 0x3f800000
+
+
diff --git a/src/gas/log2.S b/src/gas/log2.S
new file mode 100644
index 0000000..0c791b5
--- /dev/null
+++ b/src/gas/log2.S
@@ -0,0 +1,1132 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#
+# log2.S
+#
+# An implementation of the log2 libm function.
+#
+# Prototype:
+#
+#     double log2(double x);
+#
+
+#
+#   Algorithm:
+#       Similar to one presnted in log.S
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(log2)
+#define fname_special _log2_special@PLT
+
+
+# local variable storage offsets
+.equ    p_temp, 0x0
+.equ    stack_size, 0x18
+
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+
+    sub         $stack_size, %rsp
+
+    # compute exponent part
+    xor         %rax, %rax
+    movdqa      %xmm0, %xmm3
+    movsd       %xmm0, %xmm4
+    psrlq       $52, %xmm3
+    movd        %xmm0, %rax
+    psubq       .L__mask_1023(%rip), %xmm3
+    movdqa      %xmm0, %xmm2
+    cvtdq2pd    %xmm3, %xmm6 # xexp
+
+    #  NaN or inf
+    movdqa      %xmm0, %xmm5
+    andpd       .L__real_inf(%rip), %xmm5
+    comisd      .L__real_inf(%rip), %xmm5
+    je          .L__x_is_inf_or_nan
+
+    # check for negative numbers or zero
+    xorpd       %xmm5, %xmm5
+    comisd      %xmm5, %xmm0
+    jbe         .L__x_is_zero_or_neg
+
+    pand        .L__real_mant(%rip), %xmm2
+    subsd       .L__real_one(%rip), %xmm4
+
+    comisd      .L__mask_1023_f(%rip), %xmm6
+    je          .L__denormal_adjust
+
+.L__continue_common:    
+
+    # compute index into the log tables
+    mov         %rax, %r9
+    and         .L__mask_mant_all8(%rip), %rax
+    and         .L__mask_mant9(%rip), %r9
+    shl         $1, %r9
+    add         %r9, %rax
+    mov         %rax, p_temp(%rsp)
+
+    # near one codepath
+    andpd       .L__real_notsign(%rip), %xmm4
+    comisd      .L__real_threshold(%rip), %xmm4
+    jb          .L__near_one
+
+    # F, Y
+    movsd       p_temp(%rsp), %xmm1
+    shr         $44, %rax
+    por         .L__real_half(%rip), %xmm2
+    por         .L__real_half(%rip), %xmm1
+    lea         .L__log_F_inv(%rip), %r9
+
+    # f = F - Y, r = f * inv
+    subsd       %xmm2, %xmm1
+    mulsd       (%r9,%rax,8), %xmm1
+
+    movsd       %xmm1, %xmm2
+    movsd       %xmm1, %xmm0
+    lea         .L__log_256_lead(%rip), %r9
+
+    # poly
+    movsd       .L__real_1_over_6(%rip), %xmm3
+    movsd       .L__real_1_over_3(%rip), %xmm1
+    mulsd       %xmm2, %xmm3                         
+    mulsd       %xmm2, %xmm1                         
+    mulsd       %xmm2, %xmm0                         
+    movsd       %xmm0, %xmm4
+    addsd       .L__real_1_over_5(%rip), %xmm3
+    addsd       .L__real_1_over_2(%rip), %xmm1
+    mulsd       %xmm0, %xmm4                         
+    mulsd       %xmm2, %xmm3                         
+    mulsd       %xmm0, %xmm1                         
+    addsd       .L__real_1_over_4(%rip), %xmm3
+    addsd       %xmm2, %xmm1                         
+    mulsd       %xmm4, %xmm3                         
+    addsd       %xmm3, %xmm1                         
+
+    mulsd       .L__real_log2_e(%rip), %xmm1
+
+    # m + log2(G) - poly*log2_e
+    movsd       (%r9,%rax,8), %xmm0
+    lea         .L__log_256_tail(%rip), %rdx
+    movsd       (%rdx,%rax,8), %xmm2
+    subsd       %xmm1, %xmm2
+   
+    addsd       %xmm6, %xmm0 
+    addsd       %xmm2, %xmm0
+
+    add         $stack_size, %rsp
+    ret
+
+.p2align 4,,15
+.L__near_one:
+
+    # r = x - 1.0
+    movsd       .L__real_two(%rip), %xmm2
+    subsd       .L__real_one(%rip), %xmm0 # r
+
+    addsd       %xmm0, %xmm2
+    movsd       %xmm0, %xmm1
+    divsd       %xmm2, %xmm1 # r/(2+r) = u/2
+
+    movsd       .L__real_ca2(%rip), %xmm4
+    movsd       .L__real_ca4(%rip), %xmm5
+
+    movsd       %xmm0, %xmm6
+    mulsd       %xmm1, %xmm6 # correction
+
+    addsd       %xmm1, %xmm1 # u
+    movsd       %xmm1, %xmm2
+
+    mulsd       %xmm1, %xmm2 # u^2
+
+    mulsd       %xmm2, %xmm4
+    mulsd       %xmm2, %xmm5
+
+    addsd       .L__real_ca1(%rip), %xmm4
+    addsd       .L__real_ca3(%rip), %xmm5
+
+    mulsd       %xmm1, %xmm2 # u^3
+    mulsd       %xmm2, %xmm4
+
+    mulsd       %xmm2, %xmm2
+    mulsd       %xmm1, %xmm2 # u^7
+    mulsd       %xmm2, %xmm5
+
+    addsd       %xmm5, %xmm4
+    subsd       %xmm6, %xmm4
+
+    movdqa      %xmm0, %xmm3
+    pand        .L__mask_lower(%rip), %xmm3
+    subsd       %xmm3, %xmm0
+    addsd       %xmm0, %xmm4
+
+    movsd       %xmm3, %xmm0
+    movsd       %xmm4, %xmm1
+
+    mulsd       .L__real_log2_e_tail(%rip), %xmm4
+    mulsd       .L__real_log2_e_tail(%rip), %xmm0
+    mulsd       .L__real_log2_e_lead(%rip), %xmm1
+    mulsd       .L__real_log2_e_lead(%rip), %xmm3
+
+    addsd       %xmm4, %xmm0
+    addsd       %xmm1, %xmm0
+    addsd       %xmm3, %xmm0
+
+    add         $stack_size, %rsp
+    ret
+
+.p2align 4,,15
+.L__denormal_adjust:
+    por         .L__real_one(%rip), %xmm2
+    subsd       .L__real_one(%rip), %xmm2
+    movsd       %xmm2, %xmm5
+    pand        .L__real_mant(%rip), %xmm2
+    movd        %xmm2, %rax
+    psrlq       $52, %xmm5
+    psubd       .L__mask_2045(%rip), %xmm5
+    cvtdq2pd    %xmm5, %xmm6
+    jmp         .L__continue_common
+
+.p2align 4,,15
+.L__x_is_zero_or_neg:
+    jne         .L__x_is_neg
+
+    movsd       .L__real_ninf(%rip), %xmm1
+    mov         .L__flag_x_zero(%rip), %edi
+    call        fname_special
+    jmp         .L__finish
+
+.p2align 4,,15
+.L__x_is_neg:
+
+    movsd       .L__real_qnan(%rip), %xmm1
+    mov         .L__flag_x_neg(%rip), %edi
+    call        fname_special
+    jmp         .L__finish
+
+.p2align 4,,15
+.L__x_is_inf_or_nan:
+
+    cmp         .L__real_inf(%rip), %rax
+    je          .L__finish
+
+    cmp         .L__real_ninf(%rip), %rax
+    je          .L__x_is_neg
+
+    mov         .L__real_qnanbit(%rip), %r9
+    and         %rax, %r9
+    jnz         .L__finish
+
+    or          .L__real_qnanbit(%rip), %rax
+    movd        %rax, %xmm1
+    mov         .L__flag_x_nan(%rip), %edi
+    call        fname_special
+    jmp         .L__finish    
+
+.p2align 4,,15
+.L__finish:
+    add         $stack_size, %rsp
+    ret
+
+
+.data
+
+.align 16
+
+# these codes and the ones in the corresponding .c file have to match
+.L__flag_x_zero:        .long 00000001
+.L__flag_x_neg:         .long 00000002
+.L__flag_x_nan:         .long 00000003
+
+.align 16
+
+.L__real_ninf:      .quad 0x0fff0000000000000   # -inf
+                    .quad 0x0000000000000000
+.L__real_inf:       .quad 0x7ff0000000000000    # +inf
+                    .quad 0x0000000000000000
+.L__real_qnan:      .quad 0x7ff8000000000000   # qNaN
+                    .quad 0x0000000000000000
+.L__real_qnanbit:   .quad 0x0008000000000000
+                    .quad 0x0000000000000000
+.L__real_mant:      .quad 0x000FFFFFFFFFFFFF    # mantissa bits
+                    .quad 0x0000000000000000
+.L__mask_1023:      .quad 0x00000000000003ff
+                    .quad 0x0000000000000000
+.L__mask_001:       .quad 0x0000000000000001
+                    .quad 0x0000000000000000
+
+.L__mask_mant_all8:     .quad 0x000ff00000000000
+                        .quad 0x0000000000000000
+.L__mask_mant9:         .quad 0x0000080000000000
+                        .quad 0x0000000000000000
+
+.L__real_log2_e:        .quad 0x3ff71547652b82fe
+                        .quad 0x0000000000000000
+
+.L__real_log2_e_lead:   .quad 0x3ff7154400000000 # log2e_lead 1.44269180297851562500E+00
+                        .quad 0x0000000000000000
+.L__real_log2_e_tail:   .quad 0x3ecb295c17f0bbbe # log2e_tail 3.23791044778235969970E-06
+                        .quad 0x0000000000000000
+
+.L__real_two:       .quad 0x4000000000000000 # 2
+                    .quad 0x0000000000000000
+
+.L__real_one:       .quad 0x3ff0000000000000 # 1
+                    .quad 0x0000000000000000
+
+.L__real_half:      .quad 0x3fe0000000000000 # 1/2
+                    .quad 0x0000000000000000
+
+.L__mask_100:       .quad 0x0000000000000100
+                    .quad 0x0000000000000000
+
+.L__real_1_over_512:    .quad 0x3f60000000000000
+                        .quad 0x0000000000000000
+
+.L__real_1_over_2:  .quad 0x3fe0000000000000
+                    .quad 0x0000000000000000
+.L__real_1_over_3:  .quad 0x3fd5555555555555
+                    .quad 0x0000000000000000
+.L__real_1_over_4:  .quad 0x3fd0000000000000
+                    .quad 0x0000000000000000
+.L__real_1_over_5:  .quad 0x3fc999999999999a
+                    .quad 0x0000000000000000
+.L__real_1_over_6:  .quad 0x3fc5555555555555
+                    .quad 0x0000000000000000
+
+.L__mask_1023_f:    .quad 0x0c08ff80000000000
+                    .quad 0x0000000000000000
+
+.L__mask_2045:      .quad 0x00000000000007fd
+                    .quad 0x0000000000000000
+
+.L__real_threshold: .quad 0x3fb0000000000000 # .0625
+                    .quad 0x0000000000000000
+
+.L__real_notsign:   .quad 0x7ffFFFFFFFFFFFFF # ^sign bit
+                    .quad 0x0000000000000000
+
+.L__real_ca1:       .quad 0x3fb55555555554e6 # 8.33333333333317923934e-02
+                    .quad 0x0000000000000000
+.L__real_ca2:       .quad 0x3f89999999bac6d4 # 1.25000000037717509602e-02
+                    .quad 0x0000000000000000
+.L__real_ca3:       .quad 0x3f62492307f1519f # 2.23213998791944806202e-03
+                    .quad 0x0000000000000000
+.L__real_ca4:       .quad 0x3f3c8034c85dfff0 # 4.34887777707614552256e-04
+                    .quad 0x0000000000000000
+
+.L__mask_lower:     .quad 0x0ffffffff00000000
+                    .quad 0x0000000000000000
+
+.align 16
+.L__log_256_lead:
+                    .quad 0x0000000000000000
+                    .quad 0x3f7709c460000000
+                    .quad 0x3f86fe50b0000000
+                    .quad 0x3f91363110000000
+                    .quad 0x3f96e79680000000
+                    .quad 0x3f9c9363b0000000
+                    .quad 0x3fa11cd1d0000000
+                    .quad 0x3fa3ed3090000000
+                    .quad 0x3fa6bad370000000
+                    .quad 0x3fa985bfc0000000
+                    .quad 0x3fac4dfab0000000
+                    .quad 0x3faf138980000000
+                    .quad 0x3fb0eb3890000000
+                    .quad 0x3fb24b5b70000000
+                    .quad 0x3fb3aa2fd0000000
+                    .quad 0x3fb507b830000000
+                    .quad 0x3fb663f6f0000000
+                    .quad 0x3fb7beee90000000
+                    .quad 0x3fb918a160000000
+                    .quad 0x3fba7111d0000000
+                    .quad 0x3fbbc84240000000
+                    .quad 0x3fbd1e34e0000000
+                    .quad 0x3fbe72ec10000000
+                    .quad 0x3fbfc66a00000000
+                    .quad 0x3fc08c5880000000
+                    .quad 0x3fc134e1b0000000
+                    .quad 0x3fc1dcd190000000
+                    .quad 0x3fc2842940000000
+                    .quad 0x3fc32ae9e0000000
+                    .quad 0x3fc3d11460000000
+                    .quad 0x3fc476a9f0000000
+                    .quad 0x3fc51bab90000000
+                    .quad 0x3fc5c01a30000000
+                    .quad 0x3fc663f6f0000000
+                    .quad 0x3fc70742d0000000
+                    .quad 0x3fc7a9fec0000000
+                    .quad 0x3fc84c2bd0000000
+                    .quad 0x3fc8edcae0000000
+                    .quad 0x3fc98edd00000000
+                    .quad 0x3fca2f6320000000
+                    .quad 0x3fcacf5e20000000
+                    .quad 0x3fcb6ecf10000000
+                    .quad 0x3fcc0db6c0000000
+                    .quad 0x3fccac1630000000
+                    .quad 0x3fcd49ee40000000
+                    .quad 0x3fcde73fe0000000
+                    .quad 0x3fce840be0000000
+                    .quad 0x3fcf205330000000
+                    .quad 0x3fcfbc16b0000000
+                    .quad 0x3fd02baba0000000
+                    .quad 0x3fd0790ad0000000
+                    .quad 0x3fd0c62970000000
+                    .quad 0x3fd11307d0000000
+                    .quad 0x3fd15fa670000000
+                    .quad 0x3fd1ac05b0000000
+                    .quad 0x3fd1f825f0000000
+                    .quad 0x3fd24407a0000000
+                    .quad 0x3fd28fab30000000
+                    .quad 0x3fd2db10f0000000
+                    .quad 0x3fd3263960000000
+                    .quad 0x3fd37124c0000000
+                    .quad 0x3fd3bbd3a0000000
+                    .quad 0x3fd4064630000000
+                    .quad 0x3fd4507cf0000000
+                    .quad 0x3fd49a7840000000
+                    .quad 0x3fd4e43880000000
+                    .quad 0x3fd52dbdf0000000
+                    .quad 0x3fd5770910000000
+                    .quad 0x3fd5c01a30000000
+                    .quad 0x3fd608f1b0000000
+                    .quad 0x3fd6518fe0000000
+                    .quad 0x3fd699f520000000
+                    .quad 0x3fd6e221c0000000
+                    .quad 0x3fd72a1630000000
+                    .quad 0x3fd771d2b0000000
+                    .quad 0x3fd7b957a0000000
+                    .quad 0x3fd800a560000000
+                    .quad 0x3fd847bc30000000
+                    .quad 0x3fd88e9c70000000
+                    .quad 0x3fd8d54670000000
+                    .quad 0x3fd91bba80000000
+                    .quad 0x3fd961f900000000
+                    .quad 0x3fd9a80230000000
+                    .quad 0x3fd9edd670000000
+                    .quad 0x3fda337600000000
+                    .quad 0x3fda78e140000000
+                    .quad 0x3fdabe1870000000
+                    .quad 0x3fdb031be0000000
+                    .quad 0x3fdb47ebf0000000
+                    .quad 0x3fdb8c88d0000000
+                    .quad 0x3fdbd0f2e0000000
+                    .quad 0x3fdc152a60000000
+                    .quad 0x3fdc592fa0000000
+                    .quad 0x3fdc9d02f0000000
+                    .quad 0x3fdce0a490000000
+                    .quad 0x3fdd2414c0000000
+                    .quad 0x3fdd6753e0000000
+                    .quad 0x3fddaa6220000000
+                    .quad 0x3fdded3fd0000000
+                    .quad 0x3fde2fed30000000
+                    .quad 0x3fde726aa0000000
+                    .quad 0x3fdeb4b840000000
+                    .quad 0x3fdef6d670000000
+                    .quad 0x3fdf38c560000000
+                    .quad 0x3fdf7a8560000000
+                    .quad 0x3fdfbc16b0000000
+                    .quad 0x3fdffd7990000000
+                    .quad 0x3fe01f5720000000
+                    .quad 0x3fe03fda80000000
+                    .quad 0x3fe0604710000000
+                    .quad 0x3fe0809cf0000000
+                    .quad 0x3fe0a0dc30000000
+                    .quad 0x3fe0c10500000000
+                    .quad 0x3fe0e11770000000
+                    .quad 0x3fe10113b0000000
+                    .quad 0x3fe120f9d0000000
+                    .quad 0x3fe140c9f0000000
+                    .quad 0x3fe1608440000000
+                    .quad 0x3fe18028c0000000
+                    .quad 0x3fe19fb7b0000000
+                    .quad 0x3fe1bf3110000000
+                    .quad 0x3fe1de9510000000
+                    .quad 0x3fe1fde3d0000000
+                    .quad 0x3fe21d1d50000000
+                    .quad 0x3fe23c41d0000000
+                    .quad 0x3fe25b5150000000
+                    .quad 0x3fe27a4c00000000
+                    .quad 0x3fe29931f0000000
+                    .quad 0x3fe2b80340000000
+                    .quad 0x3fe2d6c010000000
+                    .quad 0x3fe2f56870000000
+                    .quad 0x3fe313fc80000000
+                    .quad 0x3fe3327c60000000
+                    .quad 0x3fe350e830000000
+                    .quad 0x3fe36f3ff0000000
+                    .quad 0x3fe38d83e0000000
+                    .quad 0x3fe3abb3f0000000
+                    .quad 0x3fe3c9d060000000
+                    .quad 0x3fe3e7d930000000
+                    .quad 0x3fe405ce80000000
+                    .quad 0x3fe423b070000000
+                    .quad 0x3fe4417f20000000
+                    .quad 0x3fe45f3a90000000
+                    .quad 0x3fe47ce2f0000000
+                    .quad 0x3fe49a7840000000
+                    .quad 0x3fe4b7fab0000000
+                    .quad 0x3fe4d56a50000000
+                    .quad 0x3fe4f2c740000000
+                    .quad 0x3fe5101180000000
+                    .quad 0x3fe52d4940000000
+                    .quad 0x3fe54a6e80000000
+                    .quad 0x3fe5678170000000
+                    .quad 0x3fe5848220000000
+                    .quad 0x3fe5a170a0000000
+                    .quad 0x3fe5be4d00000000
+                    .quad 0x3fe5db1770000000
+                    .quad 0x3fe5f7cff0000000
+                    .quad 0x3fe61476a0000000
+                    .quad 0x3fe6310b80000000
+                    .quad 0x3fe64d8ed0000000
+                    .quad 0x3fe66a0080000000
+                    .quad 0x3fe68660c0000000
+                    .quad 0x3fe6a2af90000000
+                    .quad 0x3fe6beed20000000
+                    .quad 0x3fe6db1960000000
+                    .quad 0x3fe6f73480000000
+                    .quad 0x3fe7133e90000000
+                    .quad 0x3fe72f37a0000000
+                    .quad 0x3fe74b1fd0000000
+                    .quad 0x3fe766f720000000
+                    .quad 0x3fe782bdb0000000
+                    .quad 0x3fe79e73a0000000
+                    .quad 0x3fe7ba18f0000000
+                    .quad 0x3fe7d5adc0000000
+                    .quad 0x3fe7f13220000000
+                    .quad 0x3fe80ca620000000
+                    .quad 0x3fe82809d0000000
+                    .quad 0x3fe8435d50000000
+                    .quad 0x3fe85ea0b0000000
+                    .quad 0x3fe879d3f0000000
+                    .quad 0x3fe894f740000000
+                    .quad 0x3fe8b00aa0000000
+                    .quad 0x3fe8cb0e30000000
+                    .quad 0x3fe8e60200000000
+                    .quad 0x3fe900e610000000
+                    .quad 0x3fe91bba80000000
+                    .quad 0x3fe9367f60000000
+                    .quad 0x3fe95134d0000000
+                    .quad 0x3fe96bdad0000000
+                    .quad 0x3fe9867170000000
+                    .quad 0x3fe9a0f8d0000000
+                    .quad 0x3fe9bb70f0000000
+                    .quad 0x3fe9d5d9f0000000
+                    .quad 0x3fe9f033e0000000
+                    .quad 0x3fea0a7ed0000000
+                    .quad 0x3fea24bad0000000
+                    .quad 0x3fea3ee7f0000000
+                    .quad 0x3fea590640000000
+                    .quad 0x3fea7315d0000000
+                    .quad 0x3fea8d16b0000000
+                    .quad 0x3feaa708f0000000
+                    .quad 0x3feac0eca0000000
+                    .quad 0x3feadac1e0000000
+                    .quad 0x3feaf488b0000000
+                    .quad 0x3feb0e4120000000
+                    .quad 0x3feb27eb40000000
+                    .quad 0x3feb418730000000
+                    .quad 0x3feb5b14f0000000
+                    .quad 0x3feb749480000000
+                    .quad 0x3feb8e0620000000
+                    .quad 0x3feba769b0000000
+                    .quad 0x3febc0bf50000000
+                    .quad 0x3febda0710000000
+                    .quad 0x3febf34110000000
+                    .quad 0x3fec0c6d40000000
+                    .quad 0x3fec258bc0000000
+                    .quad 0x3fec3e9ca0000000
+                    .quad 0x3fec579fe0000000
+                    .quad 0x3fec7095a0000000
+                    .quad 0x3fec897df0000000
+                    .quad 0x3feca258d0000000
+                    .quad 0x3fecbb2660000000
+                    .quad 0x3fecd3e6a0000000
+                    .quad 0x3fecec9990000000
+                    .quad 0x3fed053f60000000
+                    .quad 0x3fed1dd810000000
+                    .quad 0x3fed3663b0000000
+                    .quad 0x3fed4ee240000000
+                    .quad 0x3fed6753e0000000
+                    .quad 0x3fed7fb890000000
+                    .quad 0x3fed981060000000
+                    .quad 0x3fedb05b60000000
+                    .quad 0x3fedc899a0000000
+                    .quad 0x3fede0cb30000000
+                    .quad 0x3fedf8f020000000
+                    .quad 0x3fee110860000000
+                    .quad 0x3fee291420000000
+                    .quad 0x3fee411360000000
+                    .quad 0x3fee590630000000
+                    .quad 0x3fee70eca0000000
+                    .quad 0x3fee88c6b0000000
+                    .quad 0x3feea09470000000
+                    .quad 0x3feeb855f0000000
+                    .quad 0x3feed00b40000000
+                    .quad 0x3feee7b470000000
+                    .quad 0x3feeff5180000000
+                    .quad 0x3fef16e280000000
+                    .quad 0x3fef2e6780000000
+                    .quad 0x3fef45e080000000
+                    .quad 0x3fef5d4da0000000
+                    .quad 0x3fef74aef0000000
+                    .quad 0x3fef8c0460000000
+                    .quad 0x3fefa34e10000000
+                    .quad 0x3fefba8c00000000
+                    .quad 0x3fefd1be40000000
+                    .quad 0x3fefe8e4f0000000
+                    .quad 0x3ff0000000000000
+
+.align 16
+.L__log_256_tail:
+                    .quad 0x0000000000000000
+                    .quad 0x3deaf558ee95b37a
+                    .quad 0x3debbc2145fe38de
+                    .quad 0x3dfea5ec312ed069
+                    .quad 0x3df70b48a629b89f
+                    .quad 0x3e050a1f0cccdd01
+                    .quad 0x3e044cd04bb60514
+                    .quad 0x3e01a16898809d2d
+                    .quad 0x3e063bf61cc4d81b
+                    .quad 0x3dfa4a8ca305071d
+                    .quad 0x3e121556bde9f1f0
+                    .quad 0x3df9929cfd0e6835
+                    .quad 0x3e2f453f35679ee9
+                    .quad 0x3e2c26b47913459e
+                    .quad 0x3e2a4fe385b009a2
+                    .quad 0x3e180ceedb53cb4d
+                    .quad 0x3e2592262cf998a7
+                    .quad 0x3e1ae28a04f106b8
+                    .quad 0x3e2c8c66b55ce464
+                    .quad 0x3e2e690927d688b0
+                    .quad 0x3de5b5774c7658b4
+                    .quad 0x3e0adc16d26859c7
+                    .quad 0x3df7fa5b21cbdb5d
+                    .quad 0x3e2e160149209a68
+                    .quad 0x3e39b4f3c72c4f78
+                    .quad 0x3e222418b7fcd690
+                    .quad 0x3e2d54aded7a9150
+                    .quad 0x3e360f4c7f1aed15
+                    .quad 0x3e13c570d0fa8f96
+                    .quad 0x3e3b3514c7e0166e
+                    .quad 0x3e3307ee9a6271d2
+                    .quad 0x3dee9722922c0226
+                    .quad 0x3e33f7ad0f3f4016
+                    .quad 0x3e3592262cf998a7
+                    .quad 0x3e23bc09fca70073
+                    .quad 0x3e2f41777bc5f936
+                    .quad 0x3dd781d97ee91247
+                    .quad 0x3e306a56d76b9a84
+                    .quad 0x3e2df9c37c0beb3a
+                    .quad 0x3e1905c35651c429
+                    .quad 0x3e3b69d927dfc23d
+                    .quad 0x3e2d7e57a5afb633
+                    .quad 0x3e3bb29bdc81c4db
+                    .quad 0x3e38ee1b912d8994
+                    .quad 0x3e3864b2df91e96a
+                    .quad 0x3e1d8a40770df213
+                    .quad 0x3e2d39a9331f27cf
+                    .quad 0x3e32411e4e8eea54
+                    .quad 0x3e3204d0144751b3
+                    .quad 0x3e2268331dd8bd0b
+                    .quad 0x3e47606012de0634
+                    .quad 0x3e3550aa3a93ec7e
+                    .quad 0x3e45a616eb9612e0
+                    .quad 0x3e3aec23fd65f8e1
+                    .quad 0x3e248f838294639c
+                    .quad 0x3e3b62384cafa1a3
+                    .quad 0x3e461c0e73048b72
+                    .quad 0x3e36cc9a0d8c0e85
+                    .quad 0x3e489b355ede26f4
+                    .quad 0x3e2b5941acd71f1e
+                    .quad 0x3e4d499bd9b32266
+                    .quad 0x3e043b9f52b061ba
+                    .quad 0x3e46360892eb65e6
+                    .quad 0x3e4dba9f8729ab41
+                    .quad 0x3e479a3715fc9257
+                    .quad 0x3e0d1f6d3f77ae38
+                    .quad 0x3e48992d66fb9ec1
+                    .quad 0x3e4666f195620f03
+                    .quad 0x3e43f7ad0f3f4016
+                    .quad 0x3e30a522b65bc039
+                    .quad 0x3e319dee9b9489e3
+                    .quad 0x3e323352e1a31521
+                    .quad 0x3e4b3a19bcaf1aa4
+                    .quad 0x3e3f2f060a50d366
+                    .quad 0x3e44fdf677c8dfd9
+                    .quad 0x3e48a35588aec6df
+                    .quad 0x3e28b0e2a19575b0
+                    .quad 0x3e2ec30c6e3e04a7
+                    .quad 0x3e2705912d25b325
+                    .quad 0x3e2dae1b8d59e849
+                    .quad 0x3e423e2e1169656a
+                    .quad 0x3e349d026e33d675
+                    .quad 0x3e423c465e6976da
+                    .quad 0x3e366c977e236c73
+                    .quad 0x3e44fec0a13af881
+                    .quad 0x3e3bdefbd14a0816
+                    .quad 0x3e42fe3e91c348e4
+                    .quad 0x3e4fc0c868ccc02d
+                    .quad 0x3e3ce20a829051bb
+                    .quad 0x3e47f10cf32e6bba
+                    .quad 0x3e43cf2061568859
+                    .quad 0x3e484995cb804b94
+                    .quad 0x3e4a52b6acfcfdca
+                    .quad 0x3e3b291ecf4dff1e
+                    .quad 0x3e21d2c3e64ae851
+                    .quad 0x3e4017e4faa42b7d
+                    .quad 0x3de975077f1f5f0c
+                    .quad 0x3e20327dc8093a52
+                    .quad 0x3e3108d9313aec65
+                    .quad 0x3e4a12e5301be44a
+                    .quad 0x3e1e754d20c519e1
+                    .quad 0x3e3f456f394f9727
+                    .quad 0x3e29471103e8f00d
+                    .quad 0x3e3ef3150343f8df
+                    .quad 0x3e41960d9d9c3263
+                    .quad 0x3e4204d0144751b3
+                    .quad 0x3e4507ff357398fe
+                    .quad 0x3e4dc9937fc8cafd
+                    .quad 0x3e572f32fe672868
+                    .quad 0x3e53e49d647d323e
+                    .quad 0x3e33fb81ea92d9e0
+                    .quad 0x3e43e387ef003635
+                    .quad 0x3e1ac754cb104aea
+                    .quad 0x3e4535f0444ebaaf
+                    .quad 0x3e253c8ea7b1cdda
+                    .quad 0x3e3cf0c0396a568b
+                    .quad 0x3e5543ca873c2b4a
+                    .quad 0x3e425780181e2b37
+                    .quad 0x3e5ee52ed49d71d2
+                    .quad 0x3e51e64842e2c386
+                    .quad 0x3e5d2ba01bc76a27
+                    .quad 0x3e5b39774c30f499
+                    .quad 0x3e38740932120aea
+                    .quad 0x3e576dab3462a1e8
+                    .quad 0x3e409c9f20203b31
+                    .quad 0x3e516e7a08ad0d1a
+                    .quad 0x3e46172fe015e13b
+                    .quad 0x3e49e4558147cf67
+                    .quad 0x3e4cfdeb43cfd005
+                    .quad 0x3e3a809c03254a71
+                    .quad 0x3e47acfc98509e33
+                    .quad 0x3e54366de473e474
+                    .quad 0x3e5569394d90d724
+                    .quad 0x3e32b83ec743664c
+                    .quad 0x3e56db22c4808ee5
+                    .quad 0x3df7ae84940df0e1
+                    .quad 0x3e554042cd999564
+                    .quad 0x3e4242b8488b3056
+                    .quad 0x3e4e7dc059ab8a9e
+                    .quad 0x3e5a71e977d7da5f
+                    .quad 0x3e5d30d552ce0ec3
+                    .quad 0x3e43208592b6c6b7
+                    .quad 0x3e51440e7149afff
+                    .quad 0x3e36812c371a1c87
+                    .quad 0x3e579a3715fc9257
+                    .quad 0x3e57c92f2af8b0ca
+                    .quad 0x3e56679d8894dbdf
+                    .quad 0x3e2a9f33e77507f0
+                    .quad 0x3e4c22a3e377a524
+                    .quad 0x3e3723c84a77a4dc
+                    .quad 0x3e594a871b636194
+                    .quad 0x3e570d6058f62f4d
+                    .quad 0x3e4a6274cf0e362f
+                    .quad 0x3e42fe3570af1a0b
+                    .quad 0x3e596a286955d67e
+                    .quad 0x3e442104f127091e
+                    .quad 0x3e407826bae32c6b
+                    .quad 0x3df8d8844ce77237
+                    .quad 0x3e5eaa609080d4b4
+                    .quad 0x3e4dc66fbe61efc4
+                    .quad 0x3e5c8f11979a5db6
+                    .quad 0x3e52dedf0e6f1770
+                    .quad 0x3e5cb41e1410132a
+                    .quad 0x3e32866d705c553d
+                    .quad 0x3e54ec3293b2fbe0
+                    .quad 0x3e578b8c2f4d0fe1
+                    .quad 0x3e562ad8f7ca2cff
+                    .quad 0x3e5a298b5f973a2c
+                    .quad 0x3e49381d4f1b95e0
+                    .quad 0x3e564c7bdb9bc56c
+                    .quad 0x3e5fbb4caef790fc
+                    .quad 0x3e51200c3f899927
+                    .quad 0x3e526a05c813d56e
+                    .quad 0x3e4681e2910108ee
+                    .quad 0x3e282cf15d12ecd7
+                    .quad 0x3e0a537e32446892
+                    .quad 0x3e46f9c1cb6f7010
+                    .quad 0x3e4328ddcedf39d8
+                    .quad 0x3e164f64c210df9d
+                    .quad 0x3e58f676e17cc811
+                    .quad 0x3e560ddf1680dd45
+                    .quad 0x3e5e2da951c2d91b
+                    .quad 0x3e5696777b66d115
+                    .quad 0x3e311eb3043f5601
+                    .quad 0x3e48000b33f90fd4
+                    .quad 0x3e523e2e1169656a
+                    .quad 0x3e5b41565d3990cb
+                    .quad 0x3e46138b8d9d31e6
+                    .quad 0x3e3565afaf7f6248
+                    .quad 0x3e4b68e0ba153594
+                    .quad 0x3e3d87027ef4ab9a
+                    .quad 0x3e556b9c99085939
+                    .quad 0x3e5aa02166cccab2
+                    .quad 0x3e5991d2aca399a1
+                    .quad 0x3e54982259cc625d
+                    .quad 0x3e4b9feddaab9820
+                    .quad 0x3e3c70c0f683cc68
+                    .quad 0x3e213156425e67e5
+                    .quad 0x3df79063deab051f
+                    .quad 0x3e27e2744b2b8ca5
+                    .quad 0x3e4600534df378df
+                    .quad 0x3e59322676507a79
+                    .quad 0x3e4c4720cb4558b5
+                    .quad 0x3e445e4b56add63a
+                    .quad 0x3e4af321af5e9bb5
+                    .quad 0x3e57f1e1148dad64
+                    .quad 0x3e42a4022f65e2e6
+                    .quad 0x3e11f2ccbcd0d3cc
+                    .quad 0x3e5eaa65b49696e2
+                    .quad 0x3e110e6123a74764
+                    .quad 0x3e3cf24b2077c3f6
+                    .quad 0x3e4fc8d8164754da
+                    .quad 0x3e598cfcdb6a2dbc
+                    .quad 0x3e24464a6bcdf47b
+                    .quad 0x3e41f1774d8b66a6
+                    .quad 0x3e459920a2adf6fa
+                    .quad 0x3e370d02a99b4c5a
+                    .quad 0x3e576b6cafa2532d
+                    .quad 0x3e5d23c38ec17936
+                    .quad 0x3e541b6b1b0e66c4
+                    .quad 0x3e5952662c6bfdc7
+                    .quad 0x3e4333f3d6bb35ec
+                    .quad 0x3e195120d8486e92
+                    .quad 0x3e5db8a405fac56e
+                    .quad 0x3e5a4c112ce6312e
+                    .quad 0x3e536987e1924e45
+                    .quad 0x3e33f98ea94bc1bd
+                    .quad 0x3e459718aacb6ec7
+                    .quad 0x3df975077f1f5f0c
+                    .quad 0x3e13654d88f20500
+                    .quad 0x3e40f598530f101b
+                    .quad 0x3e5145f6c94f7fd7
+                    .quad 0x3e567fead8bcce75
+                    .quad 0x3e52e67148cd0a7b
+                    .quad 0x3e10d5e5897de907
+                    .quad 0x3e5b5ee92c53d919
+                    .quad 0x3e5c1c02803f7554
+                    .quad 0x3e5d5caa7a35c9f7
+                    .quad 0x3e5910459cac3223
+                    .quad 0x3e41fbe1bb98afdf
+                    .quad 0x3e3b135395510d1e
+                    .quad 0x3e47b8f0e7b8e757
+                    .quad 0x3e519511f61a96b8
+                    .quad 0x3e5117d846ae1f8e
+                    .quad 0x3e2b3a9507d6dc1f
+                    .quad 0x3e15fa7c78c9e676
+                    .quad 0x3e2db76303b21928
+                    .quad 0x3e27eb8450ac22ed
+                    .quad 0x3e579e0caa9c9ab7
+                    .quad 0x3e59de6d7cba1bbe
+                    .quad 0x3e1df5f5baf436cb
+                    .quad 0x3e3e746344728dbf
+                    .quad 0x3e277c23362928b9
+                    .quad 0x3e4715137cfeba9f
+                    .quad 0x3e58fe55f2856443
+                    .quad 0x3e25bd1a025d9e24
+                    .quad 0x0000000000000000
+
+.align 16
+.L__log_F_inv:
+                    .quad 0x4000000000000000
+                    .quad 0x3fffe01fe01fe020
+                    .quad 0x3fffc07f01fc07f0
+                    .quad 0x3fffa11caa01fa12
+                    .quad 0x3fff81f81f81f820
+                    .quad 0x3fff6310aca0dbb5
+                    .quad 0x3fff44659e4a4271
+                    .quad 0x3fff25f644230ab5
+                    .quad 0x3fff07c1f07c1f08
+                    .quad 0x3ffee9c7f8458e02
+                    .quad 0x3ffecc07b301ecc0
+                    .quad 0x3ffeae807aba01eb
+                    .quad 0x3ffe9131abf0b767
+                    .quad 0x3ffe741aa59750e4
+                    .quad 0x3ffe573ac901e574
+                    .quad 0x3ffe3a9179dc1a73
+                    .quad 0x3ffe1e1e1e1e1e1e
+                    .quad 0x3ffe01e01e01e01e
+                    .quad 0x3ffde5d6e3f8868a
+                    .quad 0x3ffdca01dca01dca
+                    .quad 0x3ffdae6076b981db
+                    .quad 0x3ffd92f2231e7f8a
+                    .quad 0x3ffd77b654b82c34
+                    .quad 0x3ffd5cac807572b2
+                    .quad 0x3ffd41d41d41d41d
+                    .quad 0x3ffd272ca3fc5b1a
+                    .quad 0x3ffd0cb58f6ec074
+                    .quad 0x3ffcf26e5c44bfc6
+                    .quad 0x3ffcd85689039b0b
+                    .quad 0x3ffcbe6d9601cbe7
+                    .quad 0x3ffca4b3055ee191
+                    .quad 0x3ffc8b265afb8a42
+                    .quad 0x3ffc71c71c71c71c
+                    .quad 0x3ffc5894d10d4986
+                    .quad 0x3ffc3f8f01c3f8f0
+                    .quad 0x3ffc26b5392ea01c
+                    .quad 0x3ffc0e070381c0e0
+                    .quad 0x3ffbf583ee868d8b
+                    .quad 0x3ffbdd2b899406f7
+                    .quad 0x3ffbc4fd65883e7b
+                    .quad 0x3ffbacf914c1bad0
+                    .quad 0x3ffb951e2b18ff23
+                    .quad 0x3ffb7d6c3dda338b
+                    .quad 0x3ffb65e2e3beee05
+                    .quad 0x3ffb4e81b4e81b4f
+                    .quad 0x3ffb37484ad806ce
+                    .quad 0x3ffb2036406c80d9
+                    .quad 0x3ffb094b31d922a4
+                    .quad 0x3ffaf286bca1af28
+                    .quad 0x3ffadbe87f94905e
+                    .quad 0x3ffac5701ac5701b
+                    .quad 0x3ffaaf1d2f87ebfd
+                    .quad 0x3ffa98ef606a63be
+                    .quad 0x3ffa82e65130e159
+                    .quad 0x3ffa6d01a6d01a6d
+                    .quad 0x3ffa574107688a4a
+                    .quad 0x3ffa41a41a41a41a
+                    .quad 0x3ffa2c2a87c51ca0
+                    .quad 0x3ffa16d3f97a4b02
+                    .quad 0x3ffa01a01a01a01a
+                    .quad 0x3ff9ec8e951033d9
+                    .quad 0x3ff9d79f176b682d
+                    .quad 0x3ff9c2d14ee4a102
+                    .quad 0x3ff9ae24ea5510da
+                    .quad 0x3ff999999999999a
+                    .quad 0x3ff9852f0d8ec0ff
+                    .quad 0x3ff970e4f80cb872
+                    .quad 0x3ff95cbb0be377ae
+                    .quad 0x3ff948b0fcd6e9e0
+                    .quad 0x3ff934c67f9b2ce6
+                    .quad 0x3ff920fb49d0e229
+                    .quad 0x3ff90d4f120190d5
+                    .quad 0x3ff8f9c18f9c18fa
+                    .quad 0x3ff8e6527af1373f
+                    .quad 0x3ff8d3018d3018d3
+                    .quad 0x3ff8bfce8062ff3a
+                    .quad 0x3ff8acb90f6bf3aa
+                    .quad 0x3ff899c0f601899c
+                    .quad 0x3ff886e5f0abb04a
+                    .quad 0x3ff87427bcc092b9
+                    .quad 0x3ff8618618618618
+                    .quad 0x3ff84f00c2780614
+                    .quad 0x3ff83c977ab2bedd
+                    .quad 0x3ff82a4a0182a4a0
+                    .quad 0x3ff8181818181818
+                    .quad 0x3ff8060180601806
+                    .quad 0x3ff7f405fd017f40
+                    .quad 0x3ff7e225515a4f1d
+                    .quad 0x3ff7d05f417d05f4
+                    .quad 0x3ff7beb3922e017c
+                    .quad 0x3ff7ad2208e0ecc3
+                    .quad 0x3ff79baa6bb6398b
+                    .quad 0x3ff78a4c8178a4c8
+                    .quad 0x3ff77908119ac60d
+                    .quad 0x3ff767dce434a9b1
+                    .quad 0x3ff756cac201756d
+                    .quad 0x3ff745d1745d1746
+                    .quad 0x3ff734f0c541fe8d
+                    .quad 0x3ff724287f46debc
+                    .quad 0x3ff713786d9c7c09
+                    .quad 0x3ff702e05c0b8170
+                    .quad 0x3ff6f26016f26017
+                    .quad 0x3ff6e1f76b4337c7
+                    .quad 0x3ff6d1a62681c861
+                    .quad 0x3ff6c16c16c16c17
+                    .quad 0x3ff6b1490aa31a3d
+                    .quad 0x3ff6a13cd1537290
+                    .quad 0x3ff691473a88d0c0
+                    .quad 0x3ff6816816816817
+                    .quad 0x3ff6719f3601671a
+                    .quad 0x3ff661ec6a5122f9
+                    .quad 0x3ff6524f853b4aa3
+                    .quad 0x3ff642c8590b2164
+                    .quad 0x3ff63356b88ac0de
+                    .quad 0x3ff623fa77016240
+                    .quad 0x3ff614b36831ae94
+                    .quad 0x3ff6058160581606
+                    .quad 0x3ff5f66434292dfc
+                    .quad 0x3ff5e75bb8d015e7
+                    .quad 0x3ff5d867c3ece2a5
+                    .quad 0x3ff5c9882b931057
+                    .quad 0x3ff5babcc647fa91
+                    .quad 0x3ff5ac056b015ac0
+                    .quad 0x3ff59d61f123ccaa
+                    .quad 0x3ff58ed2308158ed
+                    .quad 0x3ff5805601580560
+                    .quad 0x3ff571ed3c506b3a
+                    .quad 0x3ff56397ba7c52e2
+                    .quad 0x3ff5555555555555
+                    .quad 0x3ff54725e6bb82fe
+                    .quad 0x3ff5390948f40feb
+                    .quad 0x3ff52aff56a8054b
+                    .quad 0x3ff51d07eae2f815
+                    .quad 0x3ff50f22e111c4c5
+                    .quad 0x3ff5015015015015
+                    .quad 0x3ff4f38f62dd4c9b
+                    .quad 0x3ff4e5e0a72f0539
+                    .quad 0x3ff4d843bedc2c4c
+                    .quad 0x3ff4cab88725af6e
+                    .quad 0x3ff4bd3edda68fe1
+                    .quad 0x3ff4afd6a052bf5b
+                    .quad 0x3ff4a27fad76014a
+                    .quad 0x3ff49539e3b2d067
+                    .quad 0x3ff4880522014880
+                    .quad 0x3ff47ae147ae147b
+                    .quad 0x3ff46dce34596066
+                    .quad 0x3ff460cbc7f5cf9a
+                    .quad 0x3ff453d9e2c776ca
+                    .quad 0x3ff446f86562d9fb
+                    .quad 0x3ff43a2730abee4d
+                    .quad 0x3ff42d6625d51f87
+                    .quad 0x3ff420b5265e5951
+                    .quad 0x3ff4141414141414
+                    .quad 0x3ff40782d10e6566
+                    .quad 0x3ff3fb013fb013fb
+                    .quad 0x3ff3ee8f42a5af07
+                    .quad 0x3ff3e22cbce4a902
+                    .quad 0x3ff3d5d991aa75c6
+                    .quad 0x3ff3c995a47babe7
+                    .quad 0x3ff3bd60d9232955
+                    .quad 0x3ff3b13b13b13b14
+                    .quad 0x3ff3a524387ac822
+                    .quad 0x3ff3991c2c187f63
+                    .quad 0x3ff38d22d366088e
+                    .quad 0x3ff3813813813814
+                    .quad 0x3ff3755bd1c945ee
+                    .quad 0x3ff3698df3de0748
+                    .quad 0x3ff35dce5f9f2af8
+                    .quad 0x3ff3521cfb2b78c1
+                    .quad 0x3ff34679ace01346
+                    .quad 0x3ff33ae45b57bcb2
+                    .quad 0x3ff32f5ced6a1dfa
+                    .quad 0x3ff323e34a2b10bf
+                    .quad 0x3ff3187758e9ebb6
+                    .quad 0x3ff30d190130d190
+                    .quad 0x3ff301c82ac40260
+                    .quad 0x3ff2f684bda12f68
+                    .quad 0x3ff2eb4ea1fed14b
+                    .quad 0x3ff2e025c04b8097
+                    .quad 0x3ff2d50a012d50a0
+                    .quad 0x3ff2c9fb4d812ca0
+                    .quad 0x3ff2bef98e5a3711
+                    .quad 0x3ff2b404ad012b40
+                    .quad 0x3ff2a91c92f3c105
+                    .quad 0x3ff29e4129e4129e
+                    .quad 0x3ff293725bb804a5
+                    .quad 0x3ff288b01288b013
+                    .quad 0x3ff27dfa38a1ce4d
+                    .quad 0x3ff27350b8812735
+                    .quad 0x3ff268b37cd60127
+                    .quad 0x3ff25e22708092f1
+                    .quad 0x3ff2539d7e9177b2
+                    .quad 0x3ff2492492492492
+                    .quad 0x3ff23eb79717605b
+                    .quad 0x3ff23456789abcdf
+                    .quad 0x3ff22a0122a0122a
+                    .quad 0x3ff21fb78121fb78
+                    .quad 0x3ff21579804855e6
+                    .quad 0x3ff20b470c67c0d9
+                    .quad 0x3ff2012012012012
+                    .quad 0x3ff1f7047dc11f70
+                    .quad 0x3ff1ecf43c7fb84c
+                    .quad 0x3ff1e2ef3b3fb874
+                    .quad 0x3ff1d8f5672e4abd
+                    .quad 0x3ff1cf06ada2811d
+                    .quad 0x3ff1c522fc1ce059
+                    .quad 0x3ff1bb4a4046ed29
+                    .quad 0x3ff1b17c67f2bae3
+                    .quad 0x3ff1a7b9611a7b96
+                    .quad 0x3ff19e0119e0119e
+                    .quad 0x3ff19453808ca29c
+                    .quad 0x3ff18ab083902bdb
+                    .quad 0x3ff1811811811812
+                    .quad 0x3ff1778a191bd684
+                    .quad 0x3ff16e0689427379
+                    .quad 0x3ff1648d50fc3201
+                    .quad 0x3ff15b1e5f75270d
+                    .quad 0x3ff151b9a3fdd5c9
+                    .quad 0x3ff1485f0e0acd3b
+                    .quad 0x3ff13f0e8d344724
+                    .quad 0x3ff135c81135c811
+                    .quad 0x3ff12c8b89edc0ac
+                    .quad 0x3ff12358e75d3033
+                    .quad 0x3ff11a3019a74826
+                    .quad 0x3ff1111111111111
+                    .quad 0x3ff107fbbe011080
+                    .quad 0x3ff0fef010fef011
+                    .quad 0x3ff0f5edfab325a2
+                    .quad 0x3ff0ecf56be69c90
+                    .quad 0x3ff0e40655826011
+                    .quad 0x3ff0db20a88f4696
+                    .quad 0x3ff0d24456359e3a
+                    .quad 0x3ff0c9714fbcda3b
+                    .quad 0x3ff0c0a7868b4171
+                    .quad 0x3ff0b7e6ec259dc8
+                    .quad 0x3ff0af2f722eecb5
+                    .quad 0x3ff0a6810a6810a7
+                    .quad 0x3ff09ddba6af8360
+                    .quad 0x3ff0953f39010954
+                    .quad 0x3ff08cabb37565e2
+                    .quad 0x3ff0842108421084
+                    .quad 0x3ff07b9f29b8eae2
+                    .quad 0x3ff073260a47f7c6
+                    .quad 0x3ff06ab59c7912fb
+                    .quad 0x3ff0624dd2f1a9fc
+                    .quad 0x3ff059eea0727586
+                    .quad 0x3ff05197f7d73404
+                    .quad 0x3ff04949cc1664c5
+                    .quad 0x3ff0410410410410
+                    .quad 0x3ff038c6b78247fc
+                    .quad 0x3ff03091b51f5e1a
+                    .quad 0x3ff02864fc7729e9
+                    .quad 0x3ff0204081020408
+                    .quad 0x3ff0182436517a37
+                    .quad 0x3ff0101010101010
+                    .quad 0x3ff0080402010080
+                    .quad 0x3ff0000000000000
+                    .quad 0x0000000000000000
+
+
diff --git a/src/gas/log2f.S b/src/gas/log2f.S
new file mode 100644
index 0000000..5361e0f
--- /dev/null
+++ b/src/gas/log2f.S
@@ -0,0 +1,738 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#
+# log2f.S
+#
+# An implementation of the log2f libm function.
+#
+# Prototype:
+#
+#     float log2f(float x);
+#
+
+#
+#   Algorithm:
+#       Similar to one presnted in log.S
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(log2f)
+#define fname_special _log2f_special@PLT
+
+
+# local variable storage offsets
+.equ    p_temp, 0x0
+.equ    stack_size, 0x18
+
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+
+    sub         $stack_size, %rsp
+
+    # compute exponent part
+    xor         %eax, %eax
+    movdqa      %xmm0, %xmm3
+    movss       %xmm0, %xmm4
+    psrld       $23, %xmm3
+    movd        %xmm0, %eax
+    psubd       .L__mask_127(%rip), %xmm3
+    movdqa      %xmm0, %xmm2
+    cvtdq2ps    %xmm3, %xmm5 # xexp
+
+    #  NaN or inf
+    movdqa      %xmm0, %xmm1
+    andps       .L__real_inf(%rip), %xmm1
+    comiss      .L__real_inf(%rip), %xmm1
+    je          .L__x_is_inf_or_nan
+
+    # check for negative numbers or zero
+    xorps       %xmm1, %xmm1
+    comiss      %xmm1, %xmm0
+    jbe         .L__x_is_zero_or_neg
+
+    pand        .L__real_mant(%rip), %xmm2
+    subss       .L__real_one(%rip), %xmm4
+
+    comiss      .L__real_neg127(%rip), %xmm5
+    je          .L__denormal_adjust
+
+.L__continue_common:
+
+    # compute index into the log tables
+    mov         %eax, %r9d
+    and         .L__mask_mant_all7(%rip), %eax
+    and         .L__mask_mant8(%rip), %r9d
+    shl         $1, %r9d
+    add         %r9d, %eax
+    mov         %eax, p_temp(%rsp)
+
+    # near one codepath
+    andps       .L__real_notsign(%rip), %xmm4
+    comiss      .L__real_threshold(%rip), %xmm4
+    jb          .L__near_one
+
+    # F, Y
+    movss       p_temp(%rsp), %xmm1
+    shr         $16, %eax
+    por         .L__real_half(%rip), %xmm2
+    por         .L__real_half(%rip), %xmm1
+    lea         .L__log_F_inv(%rip), %r9
+
+    # f = F - Y, r = f * inv
+    subss       %xmm2, %xmm1
+    mulss       (%r9,%rax,4), %xmm1
+
+    movss       %xmm1, %xmm2
+    movss       %xmm1, %xmm0
+
+    # poly
+    mulss       .L__real_1_over_3(%rip), %xmm2
+    mulss       %xmm1, %xmm0
+    addss       .L__real_1_over_2(%rip), %xmm2
+
+    lea         .L__log_128_tail(%rip), %r9
+    lea         .L__log_128_lead(%rip), %r10
+
+    mulss       %xmm0, %xmm2
+    movss       (%r9,%rax,4), %xmm3
+    addss       %xmm2, %xmm1
+
+    mulss       .L__real_log2_e(%rip), %xmm1
+
+    # m + log2(G) - poly*log2_e
+    subss       %xmm1, %xmm3 
+    movss       %xmm3, %xmm0
+    addss       (%r10,%rax,4), %xmm5
+    addss       %xmm5, %xmm0
+
+    add         $stack_size, %rsp
+    ret
+
+.p2align 4,,15
+.L__near_one:
+    # r = x - 1.0#
+    movss       .L__real_two(%rip), %xmm2
+    subss       .L__real_one(%rip), %xmm0
+
+    # u = r / (2.0 + r)
+    addss       %xmm0, %xmm2
+    movss       %xmm0, %xmm1
+    divss       %xmm2, %xmm1 # u
+
+    # correction = r * u
+    movss       %xmm0, %xmm4
+    mulss       %xmm1, %xmm4
+
+    # u = u + u#
+    addss       %xmm1, %xmm1
+    movss       %xmm1, %xmm2
+    mulss       %xmm2, %xmm2 # v = u^2
+
+    # r2 = (u * v * (ca_1 + v * ca_2) - correction)
+    movss       %xmm1, %xmm3
+    mulss       %xmm2, %xmm3 # u^3
+    mulss       .L__real_ca2(%rip), %xmm2 # Bu^2
+    addss       .L__real_ca1(%rip), %xmm2 # +A
+    mulss       %xmm3, %xmm2
+    subss       %xmm4, %xmm2 # -correction
+
+    movdqa      %xmm0, %xmm5
+    pand        .L__mask_lower(%rip), %xmm5
+    subss       %xmm5, %xmm0
+    addss       %xmm0, %xmm2
+
+    movss       %xmm5, %xmm0
+    movss       %xmm2, %xmm1
+
+    mulss       .L__real_log2_e_tail(%rip), %xmm2
+    mulss       .L__real_log2_e_tail(%rip), %xmm0
+    mulss       .L__real_log2_e_lead(%rip), %xmm1
+    mulss       .L__real_log2_e_lead(%rip), %xmm5
+
+    addss       %xmm2, %xmm0
+    addss       %xmm1, %xmm0
+    addss       %xmm5, %xmm0
+
+    add         $stack_size, %rsp
+    ret
+
+.p2align 4,,15
+.L__denormal_adjust:
+    por         .L__real_one(%rip), %xmm2
+    subss       .L__real_one(%rip), %xmm2
+    movdqa      %xmm2, %xmm5
+    pand        .L__real_mant(%rip), %xmm2
+    movd        %xmm2, %eax
+    psrld       $23, %xmm5
+    psubd       .L__mask_253(%rip), %xmm5
+    cvtdq2ps    %xmm5, %xmm5
+    jmp         .L__continue_common
+
+.p2align 4,,15
+.L__x_is_zero_or_neg:
+    jne         .L__x_is_neg
+
+    movss       .L__real_ninf(%rip), %xmm1
+    mov         .L__flag_x_zero(%rip), %edi
+    call        fname_special
+    jmp         .L__finish
+
+.p2align 4,,15
+.L__x_is_neg:
+
+    movss       .L__real_nan(%rip), %xmm1
+    mov         .L__flag_x_neg(%rip), %edi
+    call        fname_special
+    jmp         .L__finish
+
+.p2align 4,,15
+.L__x_is_inf_or_nan:
+
+    cmp         .L__real_inf(%rip), %eax
+    je          .L__finish
+
+    cmp         .L__real_ninf(%rip), %eax
+    je          .L__x_is_neg
+
+    mov         .L__real_qnanbit(%rip), %r9d
+    and         %eax, %r9d
+    jnz         .L__finish
+
+    or          .L__real_qnanbit(%rip), %eax
+    movd        %eax, %xmm1
+    mov         .L__flag_x_nan(%rip), %edi
+    call        fname_special
+    jmp         .L__finish    
+
+.p2align 4,,15
+.L__finish:
+    add         $stack_size, %rsp
+    ret
+
+
+.data
+
+.align 16
+
+# these codes and the ones in the corresponding .c file have to match
+.L__flag_x_zero:        .long 00000001
+.L__flag_x_neg:         .long 00000002
+.L__flag_x_nan:         .long 00000003
+
+.align 16
+
+.L__real_one:           .quad 0x03f8000003f800000   # 1.0
+                        .quad 0x03f8000003f800000
+.L__real_two:           .quad 0x04000000040000000   # 1.0
+                        .quad 0x04000000040000000
+.L__real_ninf:          .quad 0x0ff800000ff800000   # -inf
+                        .quad 0x0ff800000ff800000
+.L__real_inf:           .quad 0x07f8000007f800000   # +inf
+                        .quad 0x07f8000007f800000
+.L__real_nan:           .quad 0x07fc000007fc00000   # NaN
+                        .quad 0x07fc000007fc00000
+.L__real_ef:            .quad 0x0402DF854402DF854   # float e
+                        .quad 0x0402DF854402DF854
+.L__real_neg_qnan:      .quad 0x0ffc00000ffc00000
+                        .quad 0x0ffc00000ffc00000
+
+.L__real_sign:          .quad 0x08000000080000000   # sign bit
+                        .quad 0x08000000080000000
+.L__real_notsign:       .quad 0x07ffFFFFF7ffFFFFF   # ^sign bit
+                        .quad 0x07ffFFFFF7ffFFFFF
+.L__real_qnanbit:       .quad 0x00040000000400000   # quiet nan bit
+                        .quad 0x00040000000400000
+.L__real_mant:          .quad 0x0007FFFFF007FFFFF   # mantissa bits
+                        .quad 0x0007FFFFF007FFFFF
+.L__mask_127:           .quad 0x00000007f0000007f   # 
+                        .quad 0x00000007f0000007f
+
+.L__mask_mant_all7:     .quad 0x00000000007f0000
+                        .quad 0x00000000007f0000
+.L__mask_mant8:         .quad 0x0000000000008000
+                        .quad 0x0000000000008000
+
+.L__real_ca1:           .quad 0x03DAAAAAB3DAAAAAB   # 8.33333333333317923934e-02
+                        .quad 0x03DAAAAAB3DAAAAAB
+.L__real_ca2:           .quad 0x03C4CCCCD3C4CCCCD   # 1.25000000037717509602e-02
+                        .quad 0x03C4CCCCD3C4CCCCD
+
+.L__real_log2_lead:     .quad 0x03F3170003F317000   # 0.693115234375
+                        .quad 0x03F3170003F317000
+.L__real_log2_tail:     .quad 0x03805FDF43805FDF4   # 0.000031946183
+                        .quad 0x03805FDF43805FDF4
+.L__real_half:          .quad 0x03f0000003f000000   # 1/2
+                        .quad 0x03f0000003f000000
+
+.L__real_log2_e_lead:   .quad 0x03FB800003FB80000   # 1.4375000000
+                        .quad 0x03FB800003FB80000
+.L__real_log2_e_tail:   .quad 0x03BAA3B293BAA3B29   # 0.0051950408889633
+                        .quad 0x03BAA3B293BAA3B29
+
+.L__real_log2_e:        .quad 0x3fb8aa3b3fb8aa3b
+                        .quad 0x0000000000000000
+
+.L__mask_lower:         .quad 0x0ffff0000ffff0000
+                        .quad 0x0ffff0000ffff0000
+
+.align 16
+
+.L__real_neg127:    .long 0x0c2fe0000
+                    .long 0
+                    .quad 0
+
+.L__mask_253:       .long 0x000000fd
+                    .long 0
+                    .quad 0
+
+.L__real_threshold: .long 0x3d800000
+                    .long 0
+                    .quad 0
+
+.L__mask_01:        .long 0x00000001
+                    .long 0
+                    .quad 0
+
+.L__mask_80:        .long 0x00000080
+                    .long 0
+                    .quad 0
+
+.L__real_3b800000:  .long 0x3b800000
+                    .long 0
+                    .quad 0
+
+.L__real_1_over_3:  .long 0x3eaaaaab
+                    .long 0
+                    .quad 0
+
+.L__real_1_over_2:  .long 0x3f000000
+                    .long 0
+                    .quad 0
+
+.align 16
+.L__log_128_lead:
+                    .long 0x00000000
+                    .long 0x3c37c000
+                    .long 0x3cb70000
+                    .long 0x3d08c000
+                    .long 0x3d35c000
+                    .long 0x3d624000
+                    .long 0x3d874000
+                    .long 0x3d9d4000
+                    .long 0x3db30000
+                    .long 0x3dc8c000
+                    .long 0x3dde4000
+                    .long 0x3df38000
+                    .long 0x3e044000
+                    .long 0x3e0ec000
+                    .long 0x3e194000
+                    .long 0x3e238000
+                    .long 0x3e2e0000
+                    .long 0x3e380000
+                    .long 0x3e424000
+                    .long 0x3e4c4000
+                    .long 0x3e564000
+                    .long 0x3e604000
+                    .long 0x3e6a4000
+                    .long 0x3e740000
+                    .long 0x3e7dc000
+                    .long 0x3e83c000
+                    .long 0x3e888000
+                    .long 0x3e8d4000
+                    .long 0x3e920000
+                    .long 0x3e96c000
+                    .long 0x3e9b8000
+                    .long 0x3ea00000
+                    .long 0x3ea4c000
+                    .long 0x3ea94000
+                    .long 0x3eae0000
+                    .long 0x3eb28000
+                    .long 0x3eb70000
+                    .long 0x3ebb8000
+                    .long 0x3ec00000
+                    .long 0x3ec44000
+                    .long 0x3ec8c000
+                    .long 0x3ecd4000
+                    .long 0x3ed18000
+                    .long 0x3ed5c000
+                    .long 0x3eda0000
+                    .long 0x3ede8000
+                    .long 0x3ee2c000
+                    .long 0x3ee70000
+                    .long 0x3eeb0000
+                    .long 0x3eef4000
+                    .long 0x3ef38000
+                    .long 0x3ef78000
+                    .long 0x3efbc000
+                    .long 0x3effc000
+                    .long 0x3f01c000
+                    .long 0x3f040000
+                    .long 0x3f060000
+                    .long 0x3f080000
+                    .long 0x3f0a0000
+                    .long 0x3f0c0000
+                    .long 0x3f0dc000
+                    .long 0x3f0fc000
+                    .long 0x3f11c000
+                    .long 0x3f13c000
+                    .long 0x3f15c000
+                    .long 0x3f178000
+                    .long 0x3f198000
+                    .long 0x3f1b4000
+                    .long 0x3f1d4000
+                    .long 0x3f1f0000
+                    .long 0x3f210000
+                    .long 0x3f22c000
+                    .long 0x3f24c000
+                    .long 0x3f268000
+                    .long 0x3f288000
+                    .long 0x3f2a4000
+                    .long 0x3f2c0000
+                    .long 0x3f2dc000
+                    .long 0x3f2f8000
+                    .long 0x3f318000
+                    .long 0x3f334000
+                    .long 0x3f350000
+                    .long 0x3f36c000
+                    .long 0x3f388000
+                    .long 0x3f3a4000
+                    .long 0x3f3c0000
+                    .long 0x3f3dc000
+                    .long 0x3f3f8000
+                    .long 0x3f414000
+                    .long 0x3f42c000
+                    .long 0x3f448000
+                    .long 0x3f464000
+                    .long 0x3f480000
+                    .long 0x3f498000
+                    .long 0x3f4b4000
+                    .long 0x3f4d0000
+                    .long 0x3f4e8000
+                    .long 0x3f504000
+                    .long 0x3f51c000
+                    .long 0x3f538000
+                    .long 0x3f550000
+                    .long 0x3f56c000
+                    .long 0x3f584000
+                    .long 0x3f5a0000
+                    .long 0x3f5b8000
+                    .long 0x3f5d0000
+                    .long 0x3f5ec000
+                    .long 0x3f604000
+                    .long 0x3f61c000
+                    .long 0x3f638000
+                    .long 0x3f650000
+                    .long 0x3f668000
+                    .long 0x3f680000
+                    .long 0x3f698000
+                    .long 0x3f6b0000
+                    .long 0x3f6cc000
+                    .long 0x3f6e4000
+                    .long 0x3f6fc000
+                    .long 0x3f714000
+                    .long 0x3f72c000
+                    .long 0x3f744000
+                    .long 0x3f75c000
+                    .long 0x3f770000
+                    .long 0x3f788000
+                    .long 0x3f7a0000
+                    .long 0x3f7b8000
+                    .long 0x3f7d0000
+                    .long 0x3f7e8000
+                    .long 0x3f800000
+
+.align 16
+.L__log_128_tail:
+                    .long 0x00000000
+                    .long 0x374a16dd
+                    .long 0x37f2d0b8
+                    .long 0x381a3aa2
+                    .long 0x37b4dd63
+                    .long 0x383f5721
+                    .long 0x384e27e8
+                    .long 0x380bf749
+                    .long 0x387dbeb2
+                    .long 0x37216e46
+                    .long 0x3684815b
+                    .long 0x383b045f
+                    .long 0x390b119b
+                    .long 0x391a32ea
+                    .long 0x38ba789e
+                    .long 0x39553f30
+                    .long 0x3651cfde
+                    .long 0x39685a9d
+                    .long 0x39057a05
+                    .long 0x395ba0ef
+                    .long 0x396bc5b6
+                    .long 0x3936d9bb
+                    .long 0x38772619
+                    .long 0x39017ce9
+                    .long 0x3902d720
+                    .long 0x38856dd8
+                    .long 0x3941f6b4
+                    .long 0x3980b652
+                    .long 0x3980f561
+                    .long 0x39443f13
+                    .long 0x38926752
+                    .long 0x39c8c763
+                    .long 0x391e12f3
+                    .long 0x39b7bf89
+                    .long 0x36d1cfde
+                    .long 0x38c7f233
+                    .long 0x39087367
+                    .long 0x38e95d3f
+                    .long 0x38256316
+                    .long 0x39d38e5c
+                    .long 0x396ea247
+                    .long 0x350e4788
+                    .long 0x395d829f
+                    .long 0x39c30f2f
+                    .long 0x39fd7ee7
+                    .long 0x3872e9e7
+                    .long 0x3897d694
+                    .long 0x3824923a
+                    .long 0x39ea7c06
+                    .long 0x39a7fa88
+                    .long 0x391aa879
+                    .long 0x39dace65
+                    .long 0x39215a32
+                    .long 0x39af3350
+                    .long 0x3a7b5172
+                    .long 0x389cf27f
+                    .long 0x3902806b
+                    .long 0x3909d8a9
+                    .long 0x38c9faa1
+                    .long 0x37a33dca
+                    .long 0x3a6623d2
+                    .long 0x3a3c7a61
+                    .long 0x3a083a84
+                    .long 0x39930161
+                    .long 0x35d1cfde
+                    .long 0x3a2d0ebd
+                    .long 0x399f1aad
+                    .long 0x3a67ff6d
+                    .long 0x39ecfea8
+                    .long 0x3a7b26f3
+                    .long 0x39ec1fa6
+                    .long 0x3a675314
+                    .long 0x399e12f3
+                    .long 0x3a2d4b66
+                    .long 0x370c3845
+                    .long 0x399ba329
+                    .long 0x3a1044d3
+                    .long 0x3a49a196
+                    .long 0x3a79fe83
+                    .long 0x3905c7aa
+                    .long 0x39802391
+                    .long 0x39abe796
+                    .long 0x39c65a9d
+                    .long 0x39cfa6c5
+                    .long 0x39c7f593
+                    .long 0x39af6ff7
+                    .long 0x39863e4d
+                    .long 0x391910c1
+                    .long 0x369d5be7
+                    .long 0x3a541616
+                    .long 0x3a1ee960
+                    .long 0x39c38ed2
+                    .long 0x38e61600
+                    .long 0x3a4fedb4
+                    .long 0x39f6b4ab
+                    .long 0x38f8d3b0
+                    .long 0x3a3b3faa
+                    .long 0x399fb693
+                    .long 0x3a5cfe71
+                    .long 0x39c5740b
+                    .long 0x3a611eb0
+                    .long 0x39b079c4
+                    .long 0x3a4824d7
+                    .long 0x39439a54
+                    .long 0x3a1291ea
+                    .long 0x3a6d3673
+                    .long 0x3981c731
+                    .long 0x3a0da88f
+                    .long 0x3a53945c
+                    .long 0x3895ae91
+                    .long 0x3996372a
+                    .long 0x39f9a832
+                    .long 0x3a27eda4
+                    .long 0x3a4c764f
+                    .long 0x3a6a7c06
+                    .long 0x370321eb
+                    .long 0x3899ab3f
+                    .long 0x38f02086
+                    .long 0x390a1707
+                    .long 0x39031e44
+                    .long 0x38c6b362
+                    .long 0x382bf195
+                    .long 0x3a768e36
+                    .long 0x3a5c503b
+                    .long 0x3a3c1179
+                    .long 0x3a15de1d
+                    .long 0x39d3845d
+                    .long 0x395f263f
+                    .long 0x00000000
+
+.align 16
+.L__log_F_inv:
+                    .long 0x40000000
+                    .long 0x3ffe03f8
+                    .long 0x3ffc0fc1
+                    .long 0x3ffa232d
+                    .long 0x3ff83e10
+                    .long 0x3ff6603e
+                    .long 0x3ff4898d
+                    .long 0x3ff2b9d6
+                    .long 0x3ff0f0f1
+                    .long 0x3fef2eb7
+                    .long 0x3fed7304
+                    .long 0x3febbdb3
+                    .long 0x3fea0ea1
+                    .long 0x3fe865ac
+                    .long 0x3fe6c2b4
+                    .long 0x3fe52598
+                    .long 0x3fe38e39
+                    .long 0x3fe1fc78
+                    .long 0x3fe07038
+                    .long 0x3fdee95c
+                    .long 0x3fdd67c9
+                    .long 0x3fdbeb62
+                    .long 0x3fda740e
+                    .long 0x3fd901b2
+                    .long 0x3fd79436
+                    .long 0x3fd62b81
+                    .long 0x3fd4c77b
+                    .long 0x3fd3680d
+                    .long 0x3fd20d21
+                    .long 0x3fd0b6a0
+                    .long 0x3fcf6475
+                    .long 0x3fce168a
+                    .long 0x3fcccccd
+                    .long 0x3fcb8728
+                    .long 0x3fca4588
+                    .long 0x3fc907da
+                    .long 0x3fc7ce0c
+                    .long 0x3fc6980c
+                    .long 0x3fc565c8
+                    .long 0x3fc43730
+                    .long 0x3fc30c31
+                    .long 0x3fc1e4bc
+                    .long 0x3fc0c0c1
+                    .long 0x3fbfa030
+                    .long 0x3fbe82fa
+                    .long 0x3fbd6910
+                    .long 0x3fbc5264
+                    .long 0x3fbb3ee7
+                    .long 0x3fba2e8c
+                    .long 0x3fb92144
+                    .long 0x3fb81703
+                    .long 0x3fb70fbb
+                    .long 0x3fb60b61
+                    .long 0x3fb509e7
+                    .long 0x3fb40b41
+                    .long 0x3fb30f63
+                    .long 0x3fb21643
+                    .long 0x3fb11fd4
+                    .long 0x3fb02c0b
+                    .long 0x3faf3ade
+                    .long 0x3fae4c41
+                    .long 0x3fad602b
+                    .long 0x3fac7692
+                    .long 0x3fab8f6a
+                    .long 0x3faaaaab
+                    .long 0x3fa9c84a
+                    .long 0x3fa8e83f
+                    .long 0x3fa80a81
+                    .long 0x3fa72f05
+                    .long 0x3fa655c4
+                    .long 0x3fa57eb5
+                    .long 0x3fa4a9cf
+                    .long 0x3fa3d70a
+                    .long 0x3fa3065e
+                    .long 0x3fa237c3
+                    .long 0x3fa16b31
+                    .long 0x3fa0a0a1
+                    .long 0x3f9fd80a
+                    .long 0x3f9f1166
+                    .long 0x3f9e4cad
+                    .long 0x3f9d89d9
+                    .long 0x3f9cc8e1
+                    .long 0x3f9c09c1
+                    .long 0x3f9b4c70
+                    .long 0x3f9a90e8
+                    .long 0x3f99d723
+                    .long 0x3f991f1a
+                    .long 0x3f9868c8
+                    .long 0x3f97b426
+                    .long 0x3f97012e
+                    .long 0x3f964fda
+                    .long 0x3f95a025
+                    .long 0x3f94f209
+                    .long 0x3f944581
+                    .long 0x3f939a86
+                    .long 0x3f92f114
+                    .long 0x3f924925
+                    .long 0x3f91a2b4
+                    .long 0x3f90fdbc
+                    .long 0x3f905a38
+                    .long 0x3f8fb824
+                    .long 0x3f8f177a
+                    .long 0x3f8e7835
+                    .long 0x3f8dda52
+                    .long 0x3f8d3dcb
+                    .long 0x3f8ca29c
+                    .long 0x3f8c08c1
+                    .long 0x3f8b7034
+                    .long 0x3f8ad8f3
+                    .long 0x3f8a42f8
+                    .long 0x3f89ae41
+                    .long 0x3f891ac7
+                    .long 0x3f888889
+                    .long 0x3f87f781
+                    .long 0x3f8767ab
+                    .long 0x3f86d905
+                    .long 0x3f864b8a
+                    .long 0x3f85bf37
+                    .long 0x3f853408
+                    .long 0x3f84a9fa
+                    .long 0x3f842108
+                    .long 0x3f839930
+                    .long 0x3f83126f
+                    .long 0x3f828cc0
+                    .long 0x3f820821
+                    .long 0x3f81848e
+                    .long 0x3f810204
+                    .long 0x3f808081
+                    .long 0x3f800000
+
+
diff --git a/src/gas/logf.S b/src/gas/logf.S
new file mode 100644
index 0000000..4cee0b0
--- /dev/null
+++ b/src/gas/logf.S
@@ -0,0 +1,725 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#
+# logf.S
+#
+# An implementation of the logf libm function.
+#
+# Prototype:
+#
+#     float logf(float x);
+#
+
+#
+#   Algorithm:
+#       Similar to one presnted in log.S
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(logf)
+#define fname_special _logf_special@PLT
+
+
+# local variable storage offsets
+.equ    p_temp, 0x0
+.equ    stack_size, 0x18
+
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+
+    sub         $stack_size, %rsp
+
+    # compute exponent part
+    xor         %eax, %eax
+    movdqa      %xmm0, %xmm3
+    movss       %xmm0, %xmm4
+    psrld       $23, %xmm3
+    movd        %xmm0, %eax
+    psubd       .L__mask_127(%rip), %xmm3
+    movdqa      %xmm0, %xmm2
+    cvtdq2ps    %xmm3, %xmm5 # xexp
+
+    #  NaN or inf
+    movdqa      %xmm0, %xmm1
+    andps       .L__real_inf(%rip), %xmm1
+    comiss      .L__real_inf(%rip), %xmm1
+    je          .L__x_is_inf_or_nan
+
+    # check for negative numbers or zero
+    xorps       %xmm1, %xmm1
+    comiss      %xmm1, %xmm0
+    jbe         .L__x_is_zero_or_neg
+
+    pand        .L__real_mant(%rip), %xmm2
+    subss       .L__real_one(%rip), %xmm4
+
+    comiss      .L__real_neg127(%rip), %xmm5
+    je          .L__denormal_adjust
+
+.L__continue_common:
+
+    # compute the index into the log tables
+    mov         %eax, %r9d
+    and         .L__mask_mant_all7(%rip), %eax
+    and         .L__mask_mant8(%rip), %r9d
+    shl         $1, %r9d
+    add         %r9d, %eax
+    mov         %eax, p_temp(%rsp)
+
+    # check e as a special case
+    comiss      .L__real_ef(%rip), %xmm0
+    je          .L__logf_e
+
+    # near one codepath
+    andps       .L__real_notsign(%rip), %xmm4
+    comiss      .L__real_threshold(%rip), %xmm4
+    jb          .L__near_one
+
+    # F, Y
+    movss       p_temp(%rsp), %xmm1
+    shr         $16, %eax
+    por         .L__real_half(%rip), %xmm2
+    por         .L__real_half(%rip), %xmm1
+    lea         .L__log_F_inv(%rip), %r9
+
+    # f = F - Y, r = f * inv
+    subss       %xmm2, %xmm1
+    mulss       (%r9,%rax,4), %xmm1
+
+    movss       %xmm1, %xmm2
+    movss       %xmm1, %xmm0
+
+    # poly
+    mulss       .L__real_1_over_3(%rip), %xmm2
+    mulss       %xmm1, %xmm0
+    addss       .L__real_1_over_2(%rip), %xmm2
+    movss       .L__real_log2_tail(%rip), %xmm3
+
+    lea         .L__log_128_tail(%rip), %r9
+    lea         .L__log_128_lead(%rip), %r10
+
+    mulss       %xmm0, %xmm2
+    mulss       %xmm5, %xmm3
+    addss       %xmm2, %xmm1
+
+    # m*log(2) + log(G) - poly
+    movss       .L__real_log2_lead(%rip), %xmm0
+    subss       %xmm1, %xmm3 # z2
+    mulss       %xmm5, %xmm0
+    addss       (%r9,%rax,4), %xmm3 # z2
+    addss       (%r10,%rax,4), %xmm0 # z1
+
+    addss       %xmm3, %xmm0
+
+    add         $stack_size, %rsp
+    ret
+
+.p2align 4,,15
+.L__logf_e:
+    movss       .L__real_one(%rip), %xmm0
+    add         $stack_size, %rsp
+    ret
+
+.p2align 4,,15
+.L__near_one:
+    # r = x - 1.0#
+    movss       .L__real_two(%rip), %xmm2
+    subss       .L__real_one(%rip), %xmm0
+
+    # u = r / (2.0 + r)
+    addss       %xmm0, %xmm2
+    movss       %xmm0, %xmm1
+    divss       %xmm2, %xmm1 # u
+
+    # correction = r * u
+    movss       %xmm0, %xmm4
+    mulss       %xmm1, %xmm4
+
+    # u = u + u#
+    addss       %xmm1, %xmm1
+    movss       %xmm1, %xmm2
+    mulss       %xmm2, %xmm2 # v = u^2
+
+    # r2 = (u * v * (ca_1 + v * ca_2) - correction)
+    movss       %xmm1, %xmm3
+    mulss       %xmm2, %xmm3 # u^3
+    mulss       .L__real_ca2(%rip), %xmm2 # Bu^2
+    addss       .L__real_ca1(%rip), %xmm2 # +A
+    mulss       %xmm3, %xmm2
+    subss       %xmm4, %xmm2 # -correction
+
+    # r + r2
+    addss       %xmm2, %xmm0
+    add         $stack_size, %rsp
+    ret
+
+.p2align 4,,15
+.L__denormal_adjust:
+    por         .L__real_one(%rip), %xmm2
+    subss       .L__real_one(%rip), %xmm2
+    movdqa      %xmm2, %xmm5
+    pand        .L__real_mant(%rip), %xmm2
+    movd        %xmm2, %eax
+    psrld       $23, %xmm5
+    psubd       .L__mask_253(%rip), %xmm5
+    cvtdq2ps    %xmm5, %xmm5
+    jmp         .L__continue_common
+
+.p2align 4,,15
+.L__x_is_zero_or_neg:
+    jne         .L__x_is_neg
+
+    movss       .L__real_ninf(%rip), %xmm1
+    mov         .L__flag_x_zero(%rip), %edi
+    call        fname_special
+    jmp         .L__finish
+
+.p2align 4,,15
+.L__x_is_neg:
+
+    movss       .L__real_nan(%rip), %xmm1
+    mov         .L__flag_x_neg(%rip), %edi
+    call        fname_special
+    jmp         .L__finish
+
+.p2align 4,,15
+.L__x_is_inf_or_nan:
+
+    cmp         .L__real_inf(%rip), %eax
+    je          .L__finish
+
+    cmp         .L__real_ninf(%rip), %eax
+    je          .L__x_is_neg
+
+    mov         .L__real_qnanbit(%rip), %r9d
+    and         %eax, %r9d
+    jnz         .L__finish
+
+    or          .L__real_qnanbit(%rip), %eax
+    movd        %eax, %xmm1
+    mov         .L__flag_x_nan(%rip), %edi
+    call        fname_special
+    jmp         .L__finish    
+
+.p2align 4,,15
+.L__finish:
+    add         $stack_size, %rsp
+    ret
+
+
+.data
+
+.align 16
+
+# these codes and the ones in the corresponding .c file have to match
+.L__flag_x_zero:        .long 00000001
+.L__flag_x_neg:         .long 00000002
+.L__flag_x_nan:         .long 00000003
+
+.align 16
+
+.L__real_one:           .quad 0x03f8000003f800000   # 1.0
+                        .quad 0x03f8000003f800000
+.L__real_two:           .quad 0x04000000040000000   # 1.0
+                        .quad 0x04000000040000000
+.L__real_ninf:          .quad 0x0ff800000ff800000   # -inf
+                        .quad 0x0ff800000ff800000
+.L__real_inf:           .quad 0x07f8000007f800000   # +inf
+                        .quad 0x07f8000007f800000
+.L__real_nan:           .quad 0x07fc000007fc00000   # NaN
+                        .quad 0x07fc000007fc00000
+.L__real_ef:            .quad 0x0402DF854402DF854   # float e
+                        .quad 0x0402DF854402DF854
+.L__real_neg_qnan:      .quad 0x0ffc00000ffc00000
+                        .quad 0x0ffc00000ffc00000
+
+.L__real_sign:          .quad 0x08000000080000000   # sign bit
+                        .quad 0x08000000080000000
+.L__real_notsign:       .quad 0x07ffFFFFF7ffFFFFF   # ^sign bit
+                        .quad 0x07ffFFFFF7ffFFFFF
+.L__real_qnanbit:       .quad 0x00040000000400000   # quiet nan bit
+                        .quad 0x00040000000400000
+.L__real_mant:          .quad 0x0007FFFFF007FFFFF   # mantissa bits
+                        .quad 0x0007FFFFF007FFFFF
+.L__mask_127:           .quad 0x00000007f0000007f   # 
+                        .quad 0x00000007f0000007f
+
+.L__mask_mant_all7:     .quad 0x00000000007f0000
+                        .quad 0x00000000007f0000
+.L__mask_mant8:         .quad 0x0000000000008000
+                        .quad 0x0000000000008000
+
+.L__real_ca1:           .quad 0x03DAAAAAB3DAAAAAB   # 8.33333333333317923934e-02
+                        .quad 0x03DAAAAAB3DAAAAAB
+.L__real_ca2:           .quad 0x03C4CCCCD3C4CCCCD   # 1.25000000037717509602e-02
+                        .quad 0x03C4CCCCD3C4CCCCD
+
+.L__real_log2_lead:     .quad 0x03F3170003F317000   # 0.693115234375
+                        .quad 0x03F3170003F317000
+.L__real_log2_tail:     .quad 0x03805FDF43805FDF4   # 0.000031946183
+                        .quad 0x03805FDF43805FDF4
+.L__real_half:          .quad 0x03f0000003f000000   # 1/2
+                        .quad 0x03f0000003f000000
+
+
+.align 16
+
+.L__real_neg127:    .long 0x0c2fe0000
+                    .long 0
+                    .quad 0
+
+.L__mask_253:       .long 0x000000fd
+                    .long 0
+                    .quad 0
+
+.L__real_threshold: .long 0x3d800000
+                    .long 0
+                    .quad 0
+
+.L__mask_01:        .long 0x00000001
+                    .long 0
+                    .quad 0
+
+.L__mask_80:        .long 0x00000080
+                    .long 0
+                    .quad 0
+
+.L__real_3b800000:  .long 0x3b800000
+                    .long 0
+                    .quad 0
+
+.L__real_1_over_3:  .long 0x3eaaaaab
+                    .long 0
+                    .quad 0
+
+.L__real_1_over_2:  .long 0x3f000000
+                    .long 0
+                    .quad 0
+
+.align 16
+.L__log_128_lead:
+                    .long 0x00000000
+                    .long 0x3bff0000
+                    .long 0x3c7e0000
+                    .long 0x3cbdc000
+                    .long 0x3cfc1000
+                    .long 0x3d1cf000
+                    .long 0x3d3ba000
+                    .long 0x3d5a1000
+                    .long 0x3d785000
+                    .long 0x3d8b2000
+                    .long 0x3d9a0000
+                    .long 0x3da8d000
+                    .long 0x3db78000
+                    .long 0x3dc61000
+                    .long 0x3dd49000
+                    .long 0x3de2f000
+                    .long 0x3df13000
+                    .long 0x3dff6000
+                    .long 0x3e06b000
+                    .long 0x3e0db000
+                    .long 0x3e14a000
+                    .long 0x3e1b8000
+                    .long 0x3e226000
+                    .long 0x3e293000
+                    .long 0x3e2ff000
+                    .long 0x3e36b000
+                    .long 0x3e3d5000
+                    .long 0x3e43f000
+                    .long 0x3e4a9000
+                    .long 0x3e511000
+                    .long 0x3e579000
+                    .long 0x3e5e1000
+                    .long 0x3e647000
+                    .long 0x3e6ae000
+                    .long 0x3e713000
+                    .long 0x3e778000
+                    .long 0x3e7dc000
+                    .long 0x3e820000
+                    .long 0x3e851000
+                    .long 0x3e882000
+                    .long 0x3e8b3000
+                    .long 0x3e8e4000
+                    .long 0x3e914000
+                    .long 0x3e944000
+                    .long 0x3e974000
+                    .long 0x3e9a3000
+                    .long 0x3e9d3000
+                    .long 0x3ea02000
+                    .long 0x3ea30000
+                    .long 0x3ea5f000
+                    .long 0x3ea8d000
+                    .long 0x3eabb000
+                    .long 0x3eae8000
+                    .long 0x3eb16000
+                    .long 0x3eb43000
+                    .long 0x3eb70000
+                    .long 0x3eb9c000
+                    .long 0x3ebc9000
+                    .long 0x3ebf5000
+                    .long 0x3ec21000
+                    .long 0x3ec4d000
+                    .long 0x3ec78000
+                    .long 0x3eca3000
+                    .long 0x3ecce000
+                    .long 0x3ecf9000
+                    .long 0x3ed24000
+                    .long 0x3ed4e000
+                    .long 0x3ed78000
+                    .long 0x3eda2000
+                    .long 0x3edcc000
+                    .long 0x3edf5000
+                    .long 0x3ee1e000
+                    .long 0x3ee47000
+                    .long 0x3ee70000
+                    .long 0x3ee99000
+                    .long 0x3eec1000
+                    .long 0x3eeea000
+                    .long 0x3ef12000
+                    .long 0x3ef3a000
+                    .long 0x3ef61000
+                    .long 0x3ef89000
+                    .long 0x3efb0000
+                    .long 0x3efd7000
+                    .long 0x3effe000
+                    .long 0x3f012000
+                    .long 0x3f025000
+                    .long 0x3f039000
+                    .long 0x3f04c000
+                    .long 0x3f05f000
+                    .long 0x3f072000
+                    .long 0x3f084000
+                    .long 0x3f097000
+                    .long 0x3f0aa000
+                    .long 0x3f0bc000
+                    .long 0x3f0cf000
+                    .long 0x3f0e1000
+                    .long 0x3f0f4000
+                    .long 0x3f106000
+                    .long 0x3f118000
+                    .long 0x3f12a000
+                    .long 0x3f13c000
+                    .long 0x3f14e000
+                    .long 0x3f160000
+                    .long 0x3f172000
+                    .long 0x3f183000
+                    .long 0x3f195000
+                    .long 0x3f1a7000
+                    .long 0x3f1b8000
+                    .long 0x3f1c9000
+                    .long 0x3f1db000
+                    .long 0x3f1ec000
+                    .long 0x3f1fd000
+                    .long 0x3f20e000
+                    .long 0x3f21f000
+                    .long 0x3f230000
+                    .long 0x3f241000
+                    .long 0x3f252000
+                    .long 0x3f263000
+                    .long 0x3f273000
+                    .long 0x3f284000
+                    .long 0x3f295000
+                    .long 0x3f2a5000
+                    .long 0x3f2b5000
+                    .long 0x3f2c6000
+                    .long 0x3f2d6000
+                    .long 0x3f2e6000
+                    .long 0x3f2f7000
+                    .long 0x3f307000
+                    .long 0x3f317000
+
+.align 16
+.L__log_128_tail:
+                    .long 0x00000000
+                    .long 0x3429ac41
+                    .long 0x35a8b0fc
+                    .long 0x368d83ea
+                    .long 0x361b0e78
+                    .long 0x3687b9fe
+                    .long 0x3631ec65
+                    .long 0x36dd7119
+                    .long 0x35c30045
+                    .long 0x379b7751
+                    .long 0x37ebcb0d
+                    .long 0x37839f83
+                    .long 0x37528ae5
+                    .long 0x37a2eb18
+                    .long 0x36da7495
+                    .long 0x36a91eb7
+                    .long 0x3783b715
+                    .long 0x371131db
+                    .long 0x383f3e68
+                    .long 0x38156a97
+                    .long 0x38297c0f
+                    .long 0x387e100f
+                    .long 0x3815b665
+                    .long 0x37e5e3a1
+                    .long 0x38183853
+                    .long 0x35fe719d
+                    .long 0x38448108
+                    .long 0x38503290
+                    .long 0x373539e8
+                    .long 0x385e0ff1
+                    .long 0x3864a740
+                    .long 0x3786742d
+                    .long 0x387be3cd
+                    .long 0x3685ad3e
+                    .long 0x3803b715
+                    .long 0x37adcbdc
+                    .long 0x380c36af
+                    .long 0x371652d3
+                    .long 0x38927139
+                    .long 0x38c5fcd7
+                    .long 0x38ae55d5
+                    .long 0x3818c169
+                    .long 0x38a0fde7
+                    .long 0x38ad09ef
+                    .long 0x3862bae1
+                    .long 0x38eecd4c
+                    .long 0x3798aad2
+                    .long 0x37421a1a
+                    .long 0x38c5e10e
+                    .long 0x37bf2aee
+                    .long 0x382d872d
+                    .long 0x37ee2e8a
+                    .long 0x38dedfac
+                    .long 0x3802f2b9
+                    .long 0x38481e9b
+                    .long 0x380eaa2b
+                    .long 0x38ebfb5d
+                    .long 0x38255fdd
+                    .long 0x38783b82
+                    .long 0x3851da1e
+                    .long 0x374e1b05
+                    .long 0x388f439b
+                    .long 0x38ca0e10
+                    .long 0x38cac08b
+                    .long 0x3891f65f
+                    .long 0x378121cb
+                    .long 0x386c9a9a
+                    .long 0x38949923
+                    .long 0x38777bcc
+                    .long 0x37b12d26
+                    .long 0x38a6ced3
+                    .long 0x38ebd3e6
+                    .long 0x38fbe3cd
+                    .long 0x38d785c2
+                    .long 0x387e7e00
+                    .long 0x38f392c5
+                    .long 0x37d40983
+                    .long 0x38081a7c
+                    .long 0x3784c3ad
+                    .long 0x38cce923
+                    .long 0x380f5faf
+                    .long 0x3891fd38
+                    .long 0x38ac47bc
+                    .long 0x3897042b
+                    .long 0x392952d2
+                    .long 0x396fced4
+                    .long 0x37f97073
+                    .long 0x385e9eae
+                    .long 0x3865c84a
+                    .long 0x38130ba3
+                    .long 0x3979cf16
+                    .long 0x3938cac9
+                    .long 0x38c3d2f4
+                    .long 0x39755dec
+                    .long 0x38e6b467
+                    .long 0x395c0fb8
+                    .long 0x383ebce0
+                    .long 0x38dcd192
+                    .long 0x39186bdf
+                    .long 0x392de74c
+                    .long 0x392f0944
+                    .long 0x391bff61
+                    .long 0x38e9ed44
+                    .long 0x38686dc8
+                    .long 0x396b99a7
+                    .long 0x39099c89
+                    .long 0x37a27673
+                    .long 0x390bdaa3
+                    .long 0x397069ab
+                    .long 0x388449ff
+                    .long 0x39013538
+                    .long 0x392dc268
+                    .long 0x3947f423
+                    .long 0x394ff17c
+                    .long 0x3945e10e
+                    .long 0x3929e8f5
+                    .long 0x38f85db0
+                    .long 0x38735f99
+                    .long 0x396c08db
+                    .long 0x3909e600
+                    .long 0x37b4996f
+                    .long 0x391233cc
+                    .long 0x397cead9
+                    .long 0x38adb5cd
+                    .long 0x3920261a
+                    .long 0x3958ee36
+                    .long 0x35aa4905
+                    .long 0x37cbd11e
+                    .long 0x3805fdf4
+
+.align 16
+.L__log_F_inv:
+                    .long 0x40000000
+                    .long 0x3ffe03f8
+                    .long 0x3ffc0fc1
+                    .long 0x3ffa232d
+                    .long 0x3ff83e10
+                    .long 0x3ff6603e
+                    .long 0x3ff4898d
+                    .long 0x3ff2b9d6
+                    .long 0x3ff0f0f1
+                    .long 0x3fef2eb7
+                    .long 0x3fed7304
+                    .long 0x3febbdb3
+                    .long 0x3fea0ea1
+                    .long 0x3fe865ac
+                    .long 0x3fe6c2b4
+                    .long 0x3fe52598
+                    .long 0x3fe38e39
+                    .long 0x3fe1fc78
+                    .long 0x3fe07038
+                    .long 0x3fdee95c
+                    .long 0x3fdd67c9
+                    .long 0x3fdbeb62
+                    .long 0x3fda740e
+                    .long 0x3fd901b2
+                    .long 0x3fd79436
+                    .long 0x3fd62b81
+                    .long 0x3fd4c77b
+                    .long 0x3fd3680d
+                    .long 0x3fd20d21
+                    .long 0x3fd0b6a0
+                    .long 0x3fcf6475
+                    .long 0x3fce168a
+                    .long 0x3fcccccd
+                    .long 0x3fcb8728
+                    .long 0x3fca4588
+                    .long 0x3fc907da
+                    .long 0x3fc7ce0c
+                    .long 0x3fc6980c
+                    .long 0x3fc565c8
+                    .long 0x3fc43730
+                    .long 0x3fc30c31
+                    .long 0x3fc1e4bc
+                    .long 0x3fc0c0c1
+                    .long 0x3fbfa030
+                    .long 0x3fbe82fa
+                    .long 0x3fbd6910
+                    .long 0x3fbc5264
+                    .long 0x3fbb3ee7
+                    .long 0x3fba2e8c
+                    .long 0x3fb92144
+                    .long 0x3fb81703
+                    .long 0x3fb70fbb
+                    .long 0x3fb60b61
+                    .long 0x3fb509e7
+                    .long 0x3fb40b41
+                    .long 0x3fb30f63
+                    .long 0x3fb21643
+                    .long 0x3fb11fd4
+                    .long 0x3fb02c0b
+                    .long 0x3faf3ade
+                    .long 0x3fae4c41
+                    .long 0x3fad602b
+                    .long 0x3fac7692
+                    .long 0x3fab8f6a
+                    .long 0x3faaaaab
+                    .long 0x3fa9c84a
+                    .long 0x3fa8e83f
+                    .long 0x3fa80a81
+                    .long 0x3fa72f05
+                    .long 0x3fa655c4
+                    .long 0x3fa57eb5
+                    .long 0x3fa4a9cf
+                    .long 0x3fa3d70a
+                    .long 0x3fa3065e
+                    .long 0x3fa237c3
+                    .long 0x3fa16b31
+                    .long 0x3fa0a0a1
+                    .long 0x3f9fd80a
+                    .long 0x3f9f1166
+                    .long 0x3f9e4cad
+                    .long 0x3f9d89d9
+                    .long 0x3f9cc8e1
+                    .long 0x3f9c09c1
+                    .long 0x3f9b4c70
+                    .long 0x3f9a90e8
+                    .long 0x3f99d723
+                    .long 0x3f991f1a
+                    .long 0x3f9868c8
+                    .long 0x3f97b426
+                    .long 0x3f97012e
+                    .long 0x3f964fda
+                    .long 0x3f95a025
+                    .long 0x3f94f209
+                    .long 0x3f944581
+                    .long 0x3f939a86
+                    .long 0x3f92f114
+                    .long 0x3f924925
+                    .long 0x3f91a2b4
+                    .long 0x3f90fdbc
+                    .long 0x3f905a38
+                    .long 0x3f8fb824
+                    .long 0x3f8f177a
+                    .long 0x3f8e7835
+                    .long 0x3f8dda52
+                    .long 0x3f8d3dcb
+                    .long 0x3f8ca29c
+                    .long 0x3f8c08c1
+                    .long 0x3f8b7034
+                    .long 0x3f8ad8f3
+                    .long 0x3f8a42f8
+                    .long 0x3f89ae41
+                    .long 0x3f891ac7
+                    .long 0x3f888889
+                    .long 0x3f87f781
+                    .long 0x3f8767ab
+                    .long 0x3f86d905
+                    .long 0x3f864b8a
+                    .long 0x3f85bf37
+                    .long 0x3f853408
+                    .long 0x3f84a9fa
+                    .long 0x3f842108
+                    .long 0x3f839930
+                    .long 0x3f83126f
+                    .long 0x3f828cc0
+                    .long 0x3f820821
+                    .long 0x3f81848e
+                    .long 0x3f810204
+                    .long 0x3f808081
+                    .long 0x3f800000
+
+
diff --git a/src/gas/nearbyint.S b/src/gas/nearbyint.S
new file mode 100644
index 0000000..edb1549
--- /dev/null
+++ b/src/gas/nearbyint.S
@@ -0,0 +1,98 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+# fabs.S
+#
+# An implementation of the fabs libm function.
+#
+# Prototype:
+#
+#     double fabs(double x);
+#
+
+#
+#   Algorithm:
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(nearbyint)
+#define fname_special _nearbyint_special
+
+
+# local variable storage offsets
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:                                                      
+    movsd .L__2p52_mask_64(%rip),%xmm2                             
+    movsd .L__sign_mask_64(%rip),%xmm4                               
+    movsd %xmm4,%xmm6                                                 
+    movsd %xmm0,%xmm1  # move input to xmm register's xmm1 and xmm5 
+    movsd %xmm0,%xmm5 
+    pand  %xmm4,%xmm1  # xmm1 = abs(xmm1) 
+    movsd %xmm1,%xmm3  # move xmm1 to xmm3
+    comisd %xmm2,%xmm1 #  
+    jnc   .L__greater_than_2p52                      # 
+    jp    .L__is_infinity_nan  # parity flag is raised if one of the xmm2 or 
+                               # xmm1 is Nan 
+.L__normal_input_case:
+    #sign.u32 = checkbits.u32[1] & 0x80000000;
+    #xmm4 = sign.u32
+    pandn %xmm5,%xmm4
+    #val_2p52.u32[1] = sign.u32 | 0x43300000;
+    #val_2p52.u32[0] = 0;
+    por   %xmm4,%xmm2
+    #val_2p52.f64 = (x + val_2p52.f64) - val_2p52.f64;
+    addpd %xmm2,%xmm5 
+    subpd %xmm5,%xmm2
+    #val_2p52.u32[1] = ((val_2p52.u32[1] << 1) >> 1) | sign.u32;
+    pand  %xmm6,%xmm2
+    por   %xmm4,%xmm2
+    movsd %xmm2,%xmm0 # move the result to xmm0 register 
+    ret
+.L__special_case:
+.L__greater_than_2p52:
+    ret # result is present in xmm0
+.L__is_infinity_nan:
+    addpd %xmm0,%xmm0
+    ret
+.align 16
+.L__sign_mask_64:          .quad 0x7FFFFFFFFFFFFFFF
+                           .quad 0
+.L__2p52_mask_64:          .quad 0x4330000000000000 
+                           .quad 0
+.L__exp_mask_64:           .quad 0x7FF0000000000000
+                           .quad 0
+
+
+
+
+
+
diff --git a/src/gas/pow.S b/src/gas/pow.S
new file mode 100644
index 0000000..8028b83
--- /dev/null
+++ b/src/gas/pow.S
@@ -0,0 +1,2244 @@
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+#ifdef __x86_64__
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+# pow.S
+#
+# An implementation of the pow libm function.
+#
+# Prototype:
+#
+#     double pow(double x, double y);
+#
+
+#
+#   Algorithm:
+#       x^y = e^(y*ln(x))
+#
+#       Look in exp, log for the respective algorithms
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(pow)
+#define fname_special _pow_special@PLT
+
+
+# local variable storage offsets
+.equ    save_x, 0x0
+.equ    save_y, 0x10
+.equ    p_temp_exp, 0x20
+.equ    negate_result, 0x30
+.equ    save_ax, 0x40
+.equ    y_head, 0x50
+.equ    p_temp_log, 0x60
+.equ    stack_size, 0x78
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+
+    sub         $stack_size, %rsp
+
+    movsd       %xmm0, save_x(%rsp)
+    movsd       %xmm1, save_y(%rsp)
+
+    mov         save_x(%rsp), %rdx
+    mov         save_y(%rsp), %r8
+
+    mov         .L__exp_mant_mask(%rip), %r10
+    and         %r8, %r10
+    jz          .L__y_is_zero
+
+    cmp         .L__pos_one(%rip), %r8
+    je          .L__y_is_one
+
+    mov         .L__sign_mask(%rip), %r9
+    and         %rdx, %r9
+    cmp         .L__sign_mask(%rip), %r9
+    mov         .L__pos_zero(%rip), %rax
+    mov         %rax, negate_result(%rsp)    
+    je          .L__x_is_neg
+
+    cmp         .L__pos_one(%rip), %rdx
+    je          .L__x_is_pos_one
+
+    cmp         .L__pos_zero(%rip), %rdx
+    je          .L__x_is_zero
+
+    mov         .L__exp_mask(%rip), %r9
+    and         %rdx, %r9
+    cmp         .L__exp_mask(%rip), %r9
+    je          .L__x_is_inf_or_nan
+   
+    mov         .L__exp_mask(%rip), %r10
+    and         %r8, %r10
+    cmp         .L__ay_max_bound(%rip), %r10
+    jg          .L__ay_is_very_large
+
+    mov         .L__exp_mask(%rip), %r10
+    and         %r8, %r10
+    cmp         .L__ay_min_bound(%rip), %r10
+    jl          .L__ay_is_very_small
+
+    # -----------------------------
+    # compute log(x) here
+    # -----------------------------
+.L__log_x:
+
+    # compute exponent part
+    xor         %r8, %r8
+    movdqa      %xmm0, %xmm3
+    psrlq       $52, %xmm3
+    movd        %xmm0, %r8
+    psubq       .L__mask_1023(%rip), %xmm3
+    movdqa      %xmm0, %xmm2
+    cvtdq2pd    %xmm3, %xmm6 # xexp
+    pand        .L__real_mant(%rip), %xmm2
+
+    comisd      .L__mask_1023_f(%rip), %xmm6
+    je          .L__denormal_adjust
+
+.L__continue_common:
+
+    # compute index into the log tables
+    movsd       %xmm0, %xmm7
+    mov         %r8, %r9
+    and         .L__mask_mant_all8(%rip), %r8
+    and         .L__mask_mant9(%rip), %r9
+    subsd       .L__real_one(%rip), %xmm7
+    shl         %r9
+    add         %r9, %r8
+    mov         %r8, p_temp_log(%rsp)
+    andpd       .L__real_notsign(%rip), %xmm7
+
+    # F, Y, switch to near-one codepath
+    movsd       p_temp_log(%rsp), %xmm1
+    shr         $44, %r8
+    por         .L__real_half(%rip), %xmm2
+    por         .L__real_half(%rip), %xmm1
+    comisd      .L__real_threshold(%rip), %xmm7
+    lea         .L__log_F_inv_head(%rip), %r9
+    lea         .L__log_F_inv_tail(%rip), %rdx
+    jb          .L__near_one
+
+    # f = F - Y, r = f * inv
+    subsd       %xmm2, %xmm1
+    movsd       %xmm1, %xmm4
+    mulsd       (%r9,%r8,8), %xmm1
+    movsd       %xmm1, %xmm5
+    mulsd       (%rdx,%r8,8), %xmm4
+    movsd       %xmm4, %xmm7
+    addsd       %xmm4, %xmm1
+
+    movsd       %xmm1, %xmm2
+    movsd       %xmm1, %xmm0
+    lea         .L__log_256_lead(%rip), %r9
+
+    # poly
+    movsd       .L__real_1_over_6(%rip), %xmm3
+    movsd       .L__real_1_over_3(%rip), %xmm1
+    mulsd       %xmm2, %xmm3                         
+    mulsd       %xmm2, %xmm1                         
+    mulsd       %xmm2, %xmm0                         
+    subsd       %xmm2, %xmm5
+    movsd       %xmm0, %xmm4
+    addsd       .L__real_1_over_5(%rip), %xmm3
+    addsd       .L__real_1_over_2(%rip), %xmm1
+    mulsd       %xmm0, %xmm4                         
+    mulsd       %xmm2, %xmm3                         
+    mulsd       %xmm0, %xmm1                         
+    addsd       .L__real_1_over_4(%rip), %xmm3
+    addsd       %xmm5, %xmm7
+    mulsd       %xmm4, %xmm3                         
+    addsd       %xmm3, %xmm1                         
+    addsd       %xmm7, %xmm1
+
+    movsd       .L__real_log2_tail(%rip), %xmm5
+    lea         .L__log_256_tail(%rip), %rdx
+    mulsd       %xmm6, %xmm5
+    movsd       (%r9,%r8,8), %xmm0
+    subsd       %xmm1, %xmm5
+
+    movsd       (%rdx,%r8,8), %xmm3
+    addsd       %xmm5, %xmm3
+    movsd       %xmm3, %xmm1
+    subsd       %xmm2, %xmm3
+
+    movsd       .L__real_log2_lead(%rip), %xmm7
+    mulsd       %xmm6, %xmm7
+    addsd       %xmm7, %xmm0
+
+    # result of ln(x) is computed from head and tail parts, resH and resT
+    # res = ln(x) = resH + resT
+    # resH and resT are in full precision 
+
+    # resT is computed from head and tail parts, resT_h and resT_t
+    # resT = resT_h + resT_t
+
+    # now
+    # xmm3 - resT
+    # xmm0 - resH
+    # xmm1 - (resT_t)
+    # xmm2 - (-resT_h)
+
+.L__log_x_continue:
+
+    movsd       %xmm0, %xmm7
+    addsd       %xmm3, %xmm0
+    movsd       %xmm0, %xmm5
+    andpd       .L__real_fffffffff8000000(%rip), %xmm0
+   
+    # xmm0 - H
+    # xmm7 - resH
+    # xmm5 - res
+
+    mov         save_y(%rsp), %rax
+    and         .L__real_fffffffff8000000(%rip), %rax
+
+    addsd       %xmm3, %xmm2
+    subsd       %xmm5, %xmm7
+    subsd       %xmm2, %xmm1
+    addsd       %xmm3, %xmm7
+    subsd       %xmm0, %xmm5
+
+    mov         %rax, y_head(%rsp)
+    movsd       save_y(%rsp), %xmm4
+   
+    addsd       %xmm1, %xmm7 
+    addsd       %xmm5, %xmm7
+
+    # res = H + T
+    # H has leading 26 bits of precision
+    # T has full precision
+
+    # xmm0 - H
+    # xmm7 - T
+
+    movsd       y_head(%rsp), %xmm2 
+    subsd       %xmm2, %xmm4
+
+    # y is split into head and tail
+    # for y * ln(x) computation
+
+    # xmm4 - Yt
+    # xmm2 - Yh
+    # xmm0 - H
+    # xmm7 - T
+
+    movsd   %xmm4, %xmm3
+    movsd   %xmm7, %xmm5
+    movsd   %xmm0, %xmm6
+    mulsd   %xmm7, %xmm3 # YtRt
+    mulsd   %xmm0, %xmm4 # YtRh
+    mulsd   %xmm2, %xmm5 # YhRt
+    mulsd   %xmm2, %xmm6 # YhRh 
+
+    movsd   %xmm6, %xmm1
+    addsd   %xmm4, %xmm3
+    addsd   %xmm5, %xmm3
+
+    addsd   %xmm3, %xmm1
+    movsd   %xmm1, %xmm0
+
+    subsd   %xmm1, %xmm6
+    addsd   %xmm3, %xmm6 
+
+    # y * ln(x) = v + vt
+    # v and vt are in full precision 
+ 
+    # xmm0 - v
+    # xmm6 - vt
+
+    # -----------------------------
+    # compute exp( y * ln(x) ) here
+    # -----------------------------
+
+    # v * (64/ln(2))
+    movsd       .L__real_64_by_log2(%rip), %xmm7
+    movsd       %xmm0, p_temp_exp(%rsp)
+    mulsd       %xmm0, %xmm7
+    mov         p_temp_exp(%rsp), %rdx
+
+    # v < 1024*ln(2), ( v * (64/ln(2)) ) < 64*1024
+    # v >= -1075*ln(2), ( v * (64/ln(2)) ) >= 64*(-1075)
+    comisd      .L__real_p65536(%rip), %xmm7
+    ja          .L__process_result_inf
+
+    comisd      .L__real_m68800(%rip), %xmm7
+    jb          .L__process_result_zero
+
+    # n = int( v * (64/ln(2)) )
+    cvtpd2dq    %xmm7, %xmm4
+    lea         .L__two_to_jby64_head_table(%rip), %r10
+    lea         .L__two_to_jby64_tail_table(%rip), %r11
+    cvtdq2pd    %xmm4, %xmm1
+
+    # r1 = x - n * ln(2)/64 head
+    movsd       .L__real_log2_by_64_head(%rip), %xmm2
+    mulsd       %xmm1, %xmm2
+    movd        %xmm4, %ecx
+    mov         $0x3f, %rax
+    and         %ecx, %eax
+    subsd       %xmm2, %xmm0
+
+    # r2 = - n * ln(2)/64 tail
+    mulsd       .L__real_log2_by_64_tail(%rip), %xmm1
+    movsd       %xmm0, %xmm2
+
+    # m = (n - j) / 64
+    sub         %eax, %ecx
+    sar         $6, %ecx
+
+    # r1+r2
+    addsd       %xmm1, %xmm2
+    addsd       %xmm6, %xmm2 # add vt here
+    movsd       %xmm2, %xmm1
+
+    # q
+    movsd       .L__real_1_by_2(%rip), %xmm0
+    movsd       .L__real_1_by_24(%rip), %xmm3
+    movsd       .L__real_1_by_720(%rip), %xmm4
+    mulsd       %xmm2, %xmm1
+    mulsd       %xmm2, %xmm0
+    mulsd       %xmm2, %xmm3
+    mulsd       %xmm2, %xmm4
+
+    movsd       %xmm1, %xmm5
+    mulsd       %xmm2, %xmm1
+    addsd       .L__real_one(%rip), %xmm0
+    addsd       .L__real_1_by_6(%rip), %xmm3
+    mulsd       %xmm1, %xmm5
+    addsd       .L__real_1_by_120(%rip), %xmm4
+    mulsd       %xmm2, %xmm0
+    mulsd       %xmm1, %xmm3
+ 
+    mulsd       %xmm5, %xmm4
+
+    # deal with denormal results
+    xor         %r9d, %r9d
+    cmp         .L__denormal_threshold(%rip), %ecx
+
+    addsd       %xmm4, %xmm3
+    addsd       %xmm3, %xmm0
+
+    cmovle      %ecx, %r9d
+    add         $1023, %rcx
+    shl         $52, %rcx
+
+    # f1, f2
+    movsd       (%r11,%rax,8), %xmm5
+    movsd       (%r10,%rax,8), %xmm1
+    mulsd       %xmm0, %xmm5
+    mulsd       %xmm0, %xmm1
+
+    cmp         .L__real_inf(%rip), %rcx
+
+    # (f1+f2)*(1+q)
+    addsd       (%r11,%rax,8), %xmm5
+    addsd       %xmm5, %xmm1
+    addsd       (%r10,%rax,8), %xmm1
+    movsd       %xmm1, %xmm0
+
+    je          .L__process_almost_inf
+
+    test        %r9d, %r9d
+    mov         %rcx, p_temp_exp(%rsp)
+    jnz         .L__process_denormal
+    mulsd       p_temp_exp(%rsp), %xmm0
+    orpd        negate_result(%rsp), %xmm0
+
+.L__final_check:
+    add         $stack_size, %rsp
+    ret
+
+.p2align 4,,15
+.L__process_almost_inf:
+    comisd      .L__real_one(%rip), %xmm0
+    jae         .L__process_result_inf
+
+    orpd        .L__enable_almost_inf(%rip), %xmm0
+    orpd        negate_result(%rsp), %xmm0
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__process_denormal:
+    mov         %r9d, %ecx
+    xor         %r11d, %r11d
+    comisd      .L__real_one(%rip), %xmm0
+    cmovae      %ecx, %r11d
+    cmp         .L__denormal_threshold(%rip), %r11d
+    jne         .L__process_true_denormal  
+
+    mulsd       p_temp_exp(%rsp), %xmm0
+    orpd        negate_result(%rsp), %xmm0
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__process_true_denormal:
+    xor         %r8, %r8
+    cmp         .L__denormal_tiny_threshold(%rip), %rdx
+    mov         $1, %r9
+    jg          .L__process_denormal_tiny
+    add         $1074, %ecx
+    cmovs       %r8, %rcx
+    shl         %cl, %r9
+    mov         %r9, %rcx
+
+    mov         %rcx, p_temp_exp(%rsp)
+    mulsd       p_temp_exp(%rsp), %xmm0
+    orpd        negate_result(%rsp), %xmm0
+    jmp         .L__z_denormal        
+
+.p2align 4,,15
+.L__process_denormal_tiny:
+    movsd       .L__real_smallest_denormal(%rip), %xmm0
+    orpd        negate_result(%rsp), %xmm0
+    jmp         .L__z_denormal
+
+.p2align 4,,15
+.L__process_result_zero:
+    mov         .L__real_zero(%rip), %r11
+    or          negate_result(%rsp), %r11
+    jmp         .L__z_is_zero_or_inf
+ 
+.p2align 4,,15
+.L__process_result_inf:
+    mov         .L__real_inf(%rip), %r11
+    or          negate_result(%rsp), %r11
+    jmp         .L__z_is_zero_or_inf
+
+.p2align 4,,15
+.L__denormal_adjust:
+    por         .L__real_one(%rip), %xmm2
+    subsd       .L__real_one(%rip), %xmm2
+    movsd       %xmm2, %xmm5
+    pand        .L__real_mant(%rip), %xmm2
+    movd        %xmm2, %r8
+    psrlq       $52, %xmm5
+    psubd       .L__mask_2045(%rip), %xmm5
+    cvtdq2pd    %xmm5, %xmm6
+    jmp         .L__continue_common
+
+.p2align 4,,15
+.L__x_is_neg:
+
+    mov         .L__exp_mask(%rip), %r10
+    and         %r8, %r10
+    cmp         .L__ay_max_bound(%rip), %r10
+    jg          .L__ay_is_very_large
+
+    # determine if y is an integer
+    mov         .L__exp_mant_mask(%rip), %r10
+    and         %r8, %r10
+    mov         %r10, %r11
+    mov         .L__exp_shift(%rip), %rcx
+    shr         %cl, %r10
+    sub         .L__exp_bias(%rip), %r10
+    js          .L__x_is_neg_y_is_not_int
+   
+    mov         .L__exp_mant_mask(%rip), %rax
+    and         %rdx, %rax
+    mov         %rax, save_ax(%rsp)
+
+    cmp         .L__yexp_53(%rip), %r10
+    mov         %r10, %rcx
+    jg          .L__continue_after_y_int_check
+
+    mov         .L__mant_full(%rip), %r9
+    shr         %cl, %r9
+    and         %r11, %r9
+    jnz         .L__x_is_neg_y_is_not_int
+
+    mov         .L__1_before_mant(%rip), %r9
+    shr         %cl, %r9
+    and         %r11, %r9
+    jz          .L__continue_after_y_int_check
+
+    mov         .L__sign_mask(%rip), %rax
+    mov         %rax, negate_result(%rsp)    
+
+.L__continue_after_y_int_check:
+
+    cmp         .L__neg_zero(%rip), %rdx
+    je          .L__x_is_zero
+
+    cmp         .L__neg_one(%rip), %rdx
+    je          .L__x_is_neg_one
+
+    mov         .L__exp_mask(%rip), %r9
+    and         %rdx, %r9
+    cmp         .L__exp_mask(%rip), %r9
+    je          .L__x_is_inf_or_nan
+   
+    movsd       save_ax(%rsp), %xmm0
+    jmp         .L__log_x
+
+
+.p2align 4,,15
+.L__near_one:
+
+    # f = F - Y, r = f * inv
+    movsd       %xmm1, %xmm0
+    subsd       %xmm2, %xmm1
+    movsd       %xmm1, %xmm4
+
+    movsd       (%r9,%r8,8), %xmm3
+    addsd       (%rdx,%r8,8), %xmm3
+    mulsd       %xmm3, %xmm4
+    andpd       .L__real_fffffffff8000000(%rip), %xmm4
+    movsd       %xmm4, %xmm5 # r1
+    mulsd       %xmm0, %xmm4
+    subsd       %xmm4, %xmm1
+    mulsd       %xmm3, %xmm1
+    movsd       %xmm1, %xmm7 # r2
+    addsd       %xmm5, %xmm1
+
+    movsd       %xmm1, %xmm2
+    movsd       %xmm1, %xmm0
+
+    lea         .L__log_256_lead(%rip), %r9
+
+    # poly
+    movsd       .L__real_1_over_7(%rip), %xmm3
+    movsd       .L__real_1_over_4(%rip), %xmm1
+    mulsd       %xmm2, %xmm3                         
+    mulsd       %xmm2, %xmm1                         
+    mulsd       %xmm2, %xmm0                         
+    movsd       %xmm0, %xmm4
+    addsd       .L__real_1_over_6(%rip), %xmm3
+    addsd       .L__real_1_over_3(%rip), %xmm1
+    mulsd       %xmm0, %xmm4                         
+    mulsd       %xmm2, %xmm3                         
+    mulsd       %xmm2, %xmm1                         
+    addsd       .L__real_1_over_5(%rip), %xmm3
+    mulsd       %xmm2, %xmm3
+    mulsd       %xmm0, %xmm1
+    mulsd       %xmm4, %xmm3                         
+
+    movsd       %xmm5, %xmm2
+    movsd       %xmm7, %xmm0
+    mulsd       %xmm0, %xmm0
+    mulsd       .L__real_1_over_2(%rip), %xmm0
+    mulsd       %xmm7, %xmm5
+    addsd       %xmm0, %xmm5
+    addsd       %xmm7, %xmm5
+
+    movsd       %xmm2, %xmm0 
+    movsd       %xmm2, %xmm7
+    mulsd       %xmm0, %xmm0
+    mulsd       .L__real_1_over_2(%rip), %xmm0
+    movsd       %xmm0, %xmm4
+    addsd       %xmm0, %xmm2 # r1 + r1^2/2
+    subsd       %xmm2, %xmm7
+    addsd       %xmm4, %xmm7
+
+    addsd       %xmm7, %xmm3 
+    movsd       .L__real_log2_tail(%rip), %xmm4
+    addsd       %xmm3, %xmm1                         
+    mulsd       %xmm6, %xmm4
+    lea         .L__log_256_tail(%rip), %rdx
+    addsd       %xmm5, %xmm1
+    addsd       (%rdx,%r8,8), %xmm4
+    subsd       %xmm1, %xmm4
+
+    movsd       %xmm4, %xmm3
+    movsd       %xmm4, %xmm1
+    subsd       %xmm2, %xmm3
+
+    movsd       (%r9,%r8,8), %xmm0
+    movsd       .L__real_log2_lead(%rip), %xmm7
+    mulsd       %xmm6, %xmm7
+    addsd       %xmm7, %xmm0
+
+    jmp         .L__log_x_continue
+
+
+.p2align 4,,15
+.L__x_is_pos_one:
+    xor         %rax, %rax
+    mov         .L__exp_mask(%rip), %r10
+    and         %r8, %r10
+    cmp         .L__exp_mask(%rip), %r10
+    cmove       %r8, %rax
+    mov         .L__mant_mask(%rip), %r10
+    and         %rax, %r10
+    jz          .L__final_check
+
+    mov         .L__qnan_set(%rip), %r10
+    and         %r8, %r10
+    jnz         .L__final_check
+
+    movsd       save_x(%rsp), %xmm0
+    movsd       save_y(%rsp), %xmm1
+    movsd       .L__pos_one(%rip), %xmm2
+    mov         .L__flag_x_one_y_snan(%rip), %edi
+
+    call        fname_special
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__y_is_zero:
+    xor         %rax, %rax
+    mov         .L__exp_mask(%rip), %r9
+    mov         .L__real_one(%rip), %r11
+    and         %rdx, %r9
+    cmp         .L__exp_mask(%rip), %r9
+    cmove       %rdx, %rax
+    mov         .L__mant_mask(%rip), %r9
+    and         %rax, %r9
+    jnz         .L__x_is_nan
+
+    movsd       .L__real_one(%rip), %xmm0
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__y_is_one:
+    xor         %rax, %rax
+    mov         %rdx, %r11
+    mov         .L__exp_mask(%rip), %r9
+    or          .L__qnan_set(%rip), %r11
+    and         %rdx, %r9
+    cmp         .L__exp_mask(%rip), %r9
+    cmove       %rdx, %rax
+    mov         .L__mant_mask(%rip), %r9
+    and         %rax, %r9
+    jnz         .L__x_is_nan
+
+    movd        %rdx, %xmm0 
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__x_is_neg_one:
+    mov         .L__pos_one(%rip), %rdx
+    or          negate_result(%rsp), %rdx
+    xor         %rax, %rax
+    mov         %r8, %r11
+    mov         .L__exp_mask(%rip), %r10
+    or          .L__qnan_set(%rip), %r11
+    and         %r8, %r10
+    cmp         .L__exp_mask(%rip), %r10
+    cmove       %r8, %rax
+    mov         .L__mant_mask(%rip), %r10
+    and         %rax, %r10
+    jnz         .L__y_is_nan
+
+    movd        %rdx, %xmm0
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__x_is_neg_y_is_not_int:
+    mov         .L__exp_mask(%rip), %r9
+    and         %rdx, %r9
+    cmp         .L__exp_mask(%rip), %r9
+    je          .L__x_is_inf_or_nan
+
+    cmp         .L__neg_zero(%rip), %rdx
+    je          .L__x_is_zero
+
+    movsd       save_x(%rsp), %xmm0
+    movsd       save_y(%rsp), %xmm1
+    movsd       .L__qnan(%rip), %xmm2
+    mov         .L__flag_x_neg_y_notint(%rip), %edi
+
+    call        fname_special
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__ay_is_very_large:
+    mov         .L__exp_mask(%rip), %r9
+    and         %rdx, %r9
+    cmp         .L__exp_mask(%rip), %r9
+    je          .L__x_is_inf_or_nan
+
+    mov         .L__exp_mant_mask(%rip), %r9
+    and         %rdx, %r9
+    jz          .L__x_is_zero 
+
+    cmp         .L__neg_one(%rip), %rdx
+    je          .L__x_is_neg_one
+
+    mov         %rdx, %r9
+    and         .L__exp_mant_mask(%rip), %r9
+    cmp         .L__pos_one(%rip), %r9
+    jl          .L__ax_lt1_y_is_large_or_inf_or_nan
+  
+    jmp         .L__ax_gt1_y_is_large_or_inf_or_nan
+
+.p2align 4,,15
+.L__x_is_zero:
+    mov         .L__exp_mask(%rip), %r10
+    xor         %rax, %rax
+    and         %r8, %r10
+    cmp         .L__exp_mask(%rip), %r10
+    je          .L__x_is_zero_y_is_inf_or_nan
+
+    mov         .L__sign_mask(%rip), %r10
+    and         %r8, %r10
+    cmovnz      .L__pos_inf(%rip), %rax
+    jnz         .L__x_is_zero_z_is_inf
+
+    movd        %rax, %xmm0
+    orpd        negate_result(%rsp), %xmm0
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__x_is_zero_z_is_inf:
+
+    movsd       save_x(%rsp), %xmm0
+    movsd       save_y(%rsp), %xmm1
+    movd        %rax, %xmm2
+    orpd        negate_result(%rsp), %xmm2
+    mov         .L__flag_x_zero_z_inf(%rip), %edi
+
+    call        fname_special
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__x_is_zero_y_is_inf_or_nan:
+    mov         %r8, %r11
+    cmp         .L__neg_inf(%rip), %r8
+    cmove       .L__pos_inf(%rip), %rax
+    je          .L__x_is_zero_z_is_inf
+
+    or          .L__qnan_set(%rip), %r11
+    mov         .L__mant_mask(%rip), %r10
+    and         %r8, %r10
+    jnz         .L__y_is_nan
+
+    movd        %rax, %xmm0
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__x_is_inf_or_nan:
+    xor         %r11, %r11
+    mov         .L__sign_mask(%rip), %r10
+    and         %r8, %r10
+    cmovz       .L__pos_inf(%rip), %r11
+    mov         %rdx, %rax
+    mov         .L__mant_mask(%rip), %r9
+    or          .L__qnan_set(%rip), %rax
+    and         %rdx, %r9
+    cmovnz      %rax, %r11
+    jnz         .L__x_is_nan
+
+    xor         %rax, %rax
+    mov         %r8, %r9
+    mov         .L__exp_mask(%rip), %r10
+    or          .L__qnan_set(%rip), %r9
+    and         %r8, %r10
+    cmp         .L__exp_mask(%rip), %r10
+    cmove       %r8, %rax
+    mov         .L__mant_mask(%rip), %r10
+    and         %rax, %r10
+    cmovnz      %r9, %r11
+    jnz         .L__y_is_nan
+
+    movd        %r11, %xmm0
+    orpd        negate_result(%rsp), %xmm0
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__ay_is_very_small:
+    movsd       .L__pos_one(%rip), %xmm0
+    addsd       %xmm1, %xmm0
+    jmp         .L__final_check
+
+
+.p2align 4,,15
+.L__ax_lt1_y_is_large_or_inf_or_nan:
+    xor         %r11, %r11
+    mov         .L__sign_mask(%rip), %r10
+    and         %r8, %r10
+    cmovnz      .L__pos_inf(%rip), %r11
+    jmp         .L__adjust_for_nan
+
+.p2align 4,,15
+.L__ax_gt1_y_is_large_or_inf_or_nan:
+    xor         %r11, %r11
+    mov         .L__sign_mask(%rip), %r10
+    and         %r8, %r10
+    cmovz       .L__pos_inf(%rip), %r11
+
+.p2align 4,,15
+.L__adjust_for_nan:
+
+    xor         %rax, %rax
+    mov         %r8, %r9
+    mov         .L__exp_mask(%rip), %r10
+    or          .L__qnan_set(%rip), %r9
+    and         %r8, %r10
+    cmp         .L__exp_mask(%rip), %r10
+    cmove       %r8, %rax
+    mov         .L__mant_mask(%rip), %r10
+    and         %rax, %r10
+    cmovnz      %r9, %r11
+    jnz         .L__y_is_nan
+
+    test        %rax, %rax
+    jnz         .L__y_is_inf
+
+.p2align 4,,15
+.L__z_is_zero_or_inf:
+
+    mov         .L__flag_z_zero(%rip), %edi
+    test        %r11, %r11
+    cmovnz      .L__flag_z_inf(%rip), %edi
+    
+    movsd       save_x(%rsp), %xmm0
+    movsd       save_y(%rsp), %xmm1
+    movd        %r11, %xmm2
+
+    call        fname_special
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__y_is_inf:
+
+    movd        %r11, %xmm0
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__x_is_nan:
+
+    xor         %rax, %rax
+    mov         .L__exp_mask(%rip), %r10
+    and         %r8, %r10
+    cmp         .L__exp_mask(%rip), %r10
+    cmove       %r8, %rax
+    mov         .L__mant_mask(%rip), %r10
+    and         %rax, %r10
+    jnz         .L__x_is_nan_y_is_nan
+
+    mov         .L__qnan_set(%rip), %r9
+    and         %rdx, %r9
+    movd        %r11, %xmm0
+    jnz         .L__final_check
+
+    movsd       save_x(%rsp), %xmm0
+    movsd       save_y(%rsp), %xmm1
+    movd        %r11, %xmm2
+    mov         .L__flag_x_nan(%rip), %edi
+
+    call        fname_special
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__y_is_nan:
+
+    mov         .L__qnan_set(%rip), %r10
+    and         %r8, %r10
+    movd        %r11, %xmm0
+    jnz         .L__final_check
+
+    movsd       save_x(%rsp), %xmm0
+    movsd       save_y(%rsp), %xmm1
+    movd        %r11, %xmm2
+    mov         .L__flag_y_nan(%rip), %edi
+
+    call        fname_special
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__x_is_nan_y_is_nan:
+
+    mov         .L__qnan_set(%rip), %r9
+    and         %rdx, %r9
+    jz          .L__continue_xy_nan
+
+    mov         .L__qnan_set(%rip), %r10
+    and         %r8, %r10
+    jz          .L__continue_xy_nan
+
+    movd        %r11, %xmm0
+    jmp         .L__final_check
+
+.L__continue_xy_nan:    
+    movsd       save_x(%rsp), %xmm0
+    movsd       save_y(%rsp), %xmm1
+    movd        %r11, %xmm2
+    mov         .L__flag_x_nan_y_nan(%rip), %edi
+
+    call        fname_special
+    jmp         .L__final_check  
+    
+.p2align 4,,15
+.L__z_denormal:
+    
+    movsd       %xmm0, %xmm2
+    movsd       save_x(%rsp), %xmm0
+    movsd       save_y(%rsp), %xmm1
+    mov         .L__flag_z_denormal(%rip), %edi
+
+    call        fname_special
+    jmp         .L__final_check  
+
+
+.data
+.align 16
+
+# these codes and the ones in the corresponding .c file have to match
+.L__flag_x_one_y_snan:          .long 1
+.L__flag_x_zero_z_inf:          .long 2
+.L__flag_x_nan:                 .long 3
+.L__flag_y_nan:                 .long 4
+.L__flag_x_nan_y_nan:           .long 5
+.L__flag_x_neg_y_notint:        .long 6
+.L__flag_z_zero:                .long 7
+.L__flag_z_denormal:            .long 8
+.L__flag_z_inf:                 .long 9
+
+.align 16
+   
+.L__ay_max_bound:           .quad 0x43e0000000000000
+.L__ay_min_bound:           .quad 0x3c00000000000000
+.L__sign_mask:              .quad 0x8000000000000000
+.L__sign_and_exp_mask:      .quad 0x0fff0000000000000
+.L__exp_mask:               .quad 0x7ff0000000000000
+.L__neg_inf:                .quad 0x0fff0000000000000
+.L__pos_inf:                .quad 0x7ff0000000000000
+.L__pos_one:                .quad 0x3ff0000000000000
+.L__pos_zero:               .quad 0x0000000000000000
+.L__exp_mant_mask:          .quad 0x7fffffffffffffff
+.L__mant_mask:              .quad 0x000fffffffffffff
+.L__ind_pattern:            .quad 0x0fff8000000000000
+
+.L__neg_qnan:               .quad 0x0fff8000000000000
+.L__qnan:                   .quad 0x7ff8000000000000
+.L__qnan_set:               .quad 0x0008000000000000
+
+.L__neg_one:                .quad 0x0bff0000000000000
+.L__neg_zero:               .quad 0x8000000000000000
+
+.L__exp_shift:              .quad 0x0000000000000034 # 52
+.L__exp_bias:               .quad 0x00000000000003ff # 1023
+.L__exp_bias_m1:            .quad 0x00000000000003fe # 1022
+
+.L__yexp_53:                .quad 0x0000000000000035 # 53
+.L__mant_full:              .quad 0x000fffffffffffff
+.L__1_before_mant:          .quad 0x0010000000000000
+
+.L__mask_mant_all8:         .quad 0x000ff00000000000
+.L__mask_mant9:             .quad 0x0000080000000000
+
+.align 16
+.L__real_fffffffff8000000:  .quad 0x0fffffffff8000000
+                            .quad 0x0fffffffff8000000
+
+.L__mask_8000000000000000:  .quad 0x8000000000000000
+                            .quad 0x8000000000000000
+
+.L__real_4090040000000000:  .quad 0x4090040000000000
+                            .quad 0x4090040000000000
+
+.L__real_C090C80000000000:  .quad 0x0C090C80000000000
+                            .quad 0x0C090C80000000000
+
+#---------------------
+# log data
+#---------------------
+
+.align 16
+
+.L__real_ninf:  .quad 0x0fff0000000000000   # -inf
+                .quad 0x0000000000000000
+.L__real_inf:   .quad 0x7ff0000000000000    # +inf
+                .quad 0x0000000000000000
+.L__real_nan:   .quad 0x7ff8000000000000    # NaN
+                .quad 0x0000000000000000
+.L__real_mant:  .quad 0x000FFFFFFFFFFFFF    # mantissa bits
+                .quad 0x0000000000000000
+.L__mask_1023:  .quad 0x00000000000003ff
+                .quad 0x0000000000000000
+.L__mask_001:   .quad 0x0000000000000001
+                .quad 0x0000000000000000
+
+
+.L__real_log2_lead: .quad 0x3fe62e42e0000000 # log2_lead  6.93147122859954833984e-01
+                    .quad 0x0000000000000000
+.L__real_log2_tail: .quad 0x3e6efa39ef35793c # log2_tail  5.76999904754328540596e-08
+                    .quad 0x0000000000000000
+
+.L__real_two:       .quad 0x4000000000000000 # 2
+                    .quad 0x0000000000000000
+
+.L__real_one:       .quad 0x3ff0000000000000 # 1
+                    .quad 0x0000000000000000
+
+.L__real_half:      .quad 0x3fe0000000000000 # 1/2
+                    .quad 0x0000000000000000
+
+.L__mask_100:       .quad 0x0000000000000100
+                    .quad 0x0000000000000000
+
+.L__real_1_over_2:  .quad 0x3fe0000000000000
+                    .quad 0x0000000000000000
+.L__real_1_over_3:  .quad 0x3fd5555555555555
+                    .quad 0x0000000000000000
+.L__real_1_over_4:  .quad 0x3fd0000000000000
+                    .quad 0x0000000000000000
+.L__real_1_over_5:  .quad 0x3fc999999999999a
+                    .quad 0x0000000000000000
+.L__real_1_over_6:  .quad 0x3fc5555555555555
+                    .quad 0x0000000000000000
+.L__real_1_over_7:  .quad 0x3fc2492492492494
+                    .quad 0x0000000000000000
+
+.L__mask_1023_f:    .quad 0x0c08ff80000000000
+                    .quad 0x0000000000000000
+
+.L__mask_2045:      .quad 0x00000000000007fd
+                    .quad 0x0000000000000000
+
+.L__real_threshold: .quad 0x3fc0000000000000 # 0.125
+                    .quad 0x3fc0000000000000
+
+.L__real_notsign:   .quad 0x7ffFFFFFFFFFFFFF # ^sign bit
+                    .quad 0x0000000000000000
+
+
+.align 16
+.L__log_256_lead:
+                    .quad 0x0000000000000000
+                    .quad 0x3f6ff00aa0000000
+                    .quad 0x3f7fe02a60000000
+                    .quad 0x3f87dc4750000000
+                    .quad 0x3f8fc0a8b0000000
+                    .quad 0x3f93cea440000000
+                    .quad 0x3f97b91b00000000
+                    .quad 0x3f9b9fc020000000
+                    .quad 0x3f9f829b00000000
+                    .quad 0x3fa1b0d980000000
+                    .quad 0x3fa39e87b0000000
+                    .quad 0x3fa58a5ba0000000
+                    .quad 0x3fa77458f0000000
+                    .quad 0x3fa95c8300000000
+                    .quad 0x3fab42dd70000000
+                    .quad 0x3fad276b80000000
+                    .quad 0x3faf0a30c0000000
+                    .quad 0x3fb0759830000000
+                    .quad 0x3fb16536e0000000
+                    .quad 0x3fb253f620000000
+                    .quad 0x3fb341d790000000
+                    .quad 0x3fb42edcb0000000
+                    .quad 0x3fb51b0730000000
+                    .quad 0x3fb60658a0000000
+                    .quad 0x3fb6f0d280000000
+                    .quad 0x3fb7da7660000000
+                    .quad 0x3fb8c345d0000000
+                    .quad 0x3fb9ab4240000000
+                    .quad 0x3fba926d30000000
+                    .quad 0x3fbb78c820000000
+                    .quad 0x3fbc5e5480000000
+                    .quad 0x3fbd4313d0000000
+                    .quad 0x3fbe270760000000
+                    .quad 0x3fbf0a30c0000000
+                    .quad 0x3fbfec9130000000
+                    .quad 0x3fc0671510000000
+                    .quad 0x3fc0d77e70000000
+                    .quad 0x3fc1478580000000
+                    .quad 0x3fc1b72ad0000000
+                    .quad 0x3fc2266f10000000
+                    .quad 0x3fc29552f0000000
+                    .quad 0x3fc303d710000000
+                    .quad 0x3fc371fc20000000
+                    .quad 0x3fc3dfc2b0000000
+                    .quad 0x3fc44d2b60000000
+                    .quad 0x3fc4ba36f0000000
+                    .quad 0x3fc526e5e0000000
+                    .quad 0x3fc59338d0000000
+                    .quad 0x3fc5ff3070000000
+                    .quad 0x3fc66acd40000000
+                    .quad 0x3fc6d60fe0000000
+                    .quad 0x3fc740f8f0000000
+                    .quad 0x3fc7ab8900000000
+                    .quad 0x3fc815c0a0000000
+                    .quad 0x3fc87fa060000000
+                    .quad 0x3fc8e928d0000000
+                    .quad 0x3fc9525a90000000
+                    .quad 0x3fc9bb3620000000
+                    .quad 0x3fca23bc10000000
+                    .quad 0x3fca8becf0000000
+                    .quad 0x3fcaf3c940000000
+                    .quad 0x3fcb5b5190000000
+                    .quad 0x3fcbc28670000000
+                    .quad 0x3fcc296850000000
+                    .quad 0x3fcc8ff7c0000000
+                    .quad 0x3fccf63540000000
+                    .quad 0x3fcd5c2160000000
+                    .quad 0x3fcdc1bca0000000
+                    .quad 0x3fce270760000000
+                    .quad 0x3fce8c0250000000
+                    .quad 0x3fcef0adc0000000
+                    .quad 0x3fcf550a50000000
+                    .quad 0x3fcfb91860000000
+                    .quad 0x3fd00e6c40000000
+                    .quad 0x3fd0402590000000
+                    .quad 0x3fd071b850000000
+                    .quad 0x3fd0a324e0000000
+                    .quad 0x3fd0d46b50000000
+                    .quad 0x3fd1058bf0000000
+                    .quad 0x3fd1368700000000
+                    .quad 0x3fd1675ca0000000
+                    .quad 0x3fd1980d20000000
+                    .quad 0x3fd1c898c0000000
+                    .quad 0x3fd1f8ff90000000
+                    .quad 0x3fd22941f0000000
+                    .quad 0x3fd2596010000000
+                    .quad 0x3fd2895a10000000
+                    .quad 0x3fd2b93030000000
+                    .quad 0x3fd2e8e2b0000000
+                    .quad 0x3fd31871c0000000
+                    .quad 0x3fd347dd90000000
+                    .quad 0x3fd3772660000000
+                    .quad 0x3fd3a64c50000000
+                    .quad 0x3fd3d54fa0000000
+                    .quad 0x3fd4043080000000
+                    .quad 0x3fd432ef20000000
+                    .quad 0x3fd4618bc0000000
+                    .quad 0x3fd4900680000000
+                    .quad 0x3fd4be5f90000000
+                    .quad 0x3fd4ec9730000000
+                    .quad 0x3fd51aad80000000
+                    .quad 0x3fd548a2c0000000
+                    .quad 0x3fd5767710000000
+                    .quad 0x3fd5a42ab0000000
+                    .quad 0x3fd5d1bdb0000000
+                    .quad 0x3fd5ff3070000000
+                    .quad 0x3fd62c82f0000000
+                    .quad 0x3fd659b570000000
+                    .quad 0x3fd686c810000000
+                    .quad 0x3fd6b3bb20000000
+                    .quad 0x3fd6e08ea0000000
+                    .quad 0x3fd70d42e0000000
+                    .quad 0x3fd739d7f0000000
+                    .quad 0x3fd7664e10000000
+                    .quad 0x3fd792a550000000
+                    .quad 0x3fd7bede00000000
+                    .quad 0x3fd7eaf830000000
+                    .quad 0x3fd816f410000000
+                    .quad 0x3fd842d1d0000000
+                    .quad 0x3fd86e9190000000
+                    .quad 0x3fd89a3380000000
+                    .quad 0x3fd8c5b7c0000000
+                    .quad 0x3fd8f11e80000000
+                    .quad 0x3fd91c67e0000000
+                    .quad 0x3fd9479410000000
+                    .quad 0x3fd972a340000000
+                    .quad 0x3fd99d9580000000
+                    .quad 0x3fd9c86b00000000
+                    .quad 0x3fd9f323e0000000
+                    .quad 0x3fda1dc060000000
+                    .quad 0x3fda484090000000
+                    .quad 0x3fda72a490000000
+                    .quad 0x3fda9cec90000000
+                    .quad 0x3fdac718c0000000
+                    .quad 0x3fdaf12930000000
+                    .quad 0x3fdb1b1e00000000
+                    .quad 0x3fdb44f770000000
+                    .quad 0x3fdb6eb590000000
+                    .quad 0x3fdb985890000000
+                    .quad 0x3fdbc1e080000000
+                    .quad 0x3fdbeb4d90000000
+                    .quad 0x3fdc149ff0000000
+                    .quad 0x3fdc3dd7a0000000
+                    .quad 0x3fdc66f4e0000000
+                    .quad 0x3fdc8ff7c0000000
+                    .quad 0x3fdcb8e070000000
+                    .quad 0x3fdce1af00000000
+                    .quad 0x3fdd0a63a0000000
+                    .quad 0x3fdd32fe70000000
+                    .quad 0x3fdd5b7f90000000
+                    .quad 0x3fdd83e720000000
+                    .quad 0x3fddac3530000000
+                    .quad 0x3fddd46a00000000
+                    .quad 0x3fddfc8590000000
+                    .quad 0x3fde248810000000
+                    .quad 0x3fde4c71a0000000
+                    .quad 0x3fde744260000000
+                    .quad 0x3fde9bfa60000000
+                    .quad 0x3fdec399d0000000
+                    .quad 0x3fdeeb20c0000000
+                    .quad 0x3fdf128f50000000
+                    .quad 0x3fdf39e5b0000000
+                    .quad 0x3fdf6123f0000000
+                    .quad 0x3fdf884a30000000
+                    .quad 0x3fdfaf5880000000
+                    .quad 0x3fdfd64f20000000
+                    .quad 0x3fdffd2e00000000
+                    .quad 0x3fe011fab0000000
+                    .quad 0x3fe02552a0000000
+                    .quad 0x3fe0389ee0000000
+                    .quad 0x3fe04bdf90000000
+                    .quad 0x3fe05f14b0000000
+                    .quad 0x3fe0723e50000000
+                    .quad 0x3fe0855c80000000
+                    .quad 0x3fe0986f40000000
+                    .quad 0x3fe0ab76b0000000
+                    .quad 0x3fe0be72e0000000
+                    .quad 0x3fe0d163c0000000
+                    .quad 0x3fe0e44980000000
+                    .quad 0x3fe0f72410000000
+                    .quad 0x3fe109f390000000
+                    .quad 0x3fe11cb810000000
+                    .quad 0x3fe12f7190000000
+                    .quad 0x3fe1422020000000
+                    .quad 0x3fe154c3d0000000
+                    .quad 0x3fe1675ca0000000
+                    .quad 0x3fe179eab0000000
+                    .quad 0x3fe18c6e00000000
+                    .quad 0x3fe19ee6b0000000
+                    .quad 0x3fe1b154b0000000
+                    .quad 0x3fe1c3b810000000
+                    .quad 0x3fe1d610f0000000
+                    .quad 0x3fe1e85f50000000
+                    .quad 0x3fe1faa340000000
+                    .quad 0x3fe20cdcd0000000
+                    .quad 0x3fe21f0bf0000000
+                    .quad 0x3fe23130d0000000
+                    .quad 0x3fe2434b60000000
+                    .quad 0x3fe2555bc0000000
+                    .quad 0x3fe2676200000000
+                    .quad 0x3fe2795e10000000
+                    .quad 0x3fe28b5000000000
+                    .quad 0x3fe29d37f0000000
+                    .quad 0x3fe2af15f0000000
+                    .quad 0x3fe2c0e9e0000000
+                    .quad 0x3fe2d2b400000000
+                    .quad 0x3fe2e47430000000
+                    .quad 0x3fe2f62a90000000
+                    .quad 0x3fe307d730000000
+                    .quad 0x3fe3197a00000000
+                    .quad 0x3fe32b1330000000
+                    .quad 0x3fe33ca2b0000000
+                    .quad 0x3fe34e2890000000
+                    .quad 0x3fe35fa4e0000000
+                    .quad 0x3fe37117b0000000
+                    .quad 0x3fe38280f0000000
+                    .quad 0x3fe393e0d0000000
+                    .quad 0x3fe3a53730000000
+                    .quad 0x3fe3b68440000000
+                    .quad 0x3fe3c7c7f0000000
+                    .quad 0x3fe3d90260000000
+                    .quad 0x3fe3ea3390000000
+                    .quad 0x3fe3fb5b80000000
+                    .quad 0x3fe40c7a40000000
+                    .quad 0x3fe41d8fe0000000
+                    .quad 0x3fe42e9c60000000
+                    .quad 0x3fe43f9fe0000000
+                    .quad 0x3fe4509a50000000
+                    .quad 0x3fe4618bc0000000
+                    .quad 0x3fe4727430000000
+                    .quad 0x3fe48353d0000000
+                    .quad 0x3fe4942a80000000
+                    .quad 0x3fe4a4f850000000
+                    .quad 0x3fe4b5bd60000000
+                    .quad 0x3fe4c679a0000000
+                    .quad 0x3fe4d72d30000000
+                    .quad 0x3fe4e7d810000000
+                    .quad 0x3fe4f87a30000000
+                    .quad 0x3fe50913c0000000
+                    .quad 0x3fe519a4c0000000
+                    .quad 0x3fe52a2d20000000
+                    .quad 0x3fe53aad00000000
+                    .quad 0x3fe54b2460000000
+                    .quad 0x3fe55b9350000000
+                    .quad 0x3fe56bf9d0000000
+                    .quad 0x3fe57c57f0000000
+                    .quad 0x3fe58cadb0000000
+                    .quad 0x3fe59cfb20000000
+                    .quad 0x3fe5ad4040000000
+                    .quad 0x3fe5bd7d30000000
+                    .quad 0x3fe5cdb1d0000000
+                    .quad 0x3fe5ddde50000000
+                    .quad 0x3fe5ee02a0000000
+                    .quad 0x3fe5fe1ed0000000
+                    .quad 0x3fe60e32f0000000
+                    .quad 0x3fe61e3ef0000000
+                    .quad 0x3fe62e42e0000000
+                    .quad 0x0000000000000000
+
+.align 16
+.L__log_256_tail:
+                    .quad 0x0000000000000000
+                    .quad 0x3db5885e0250435a
+                    .quad 0x3de620cf11f86ed2
+                    .quad 0x3dff0214edba4a25
+                    .quad 0x3dbf807c79f3db4e
+                    .quad 0x3dea352ba779a52b
+                    .quad 0x3dff56c46aa49fd5
+                    .quad 0x3dfebe465fef5196
+                    .quad 0x3e0cf0660099f1f8
+                    .quad 0x3e1247b2ff85945d
+                    .quad 0x3e13fd7abf5202b6
+                    .quad 0x3e1f91c9a918d51e
+                    .quad 0x3e08cb73f118d3ca
+                    .quad 0x3e1d91c7d6fad074
+                    .quad 0x3de1971bec28d14c
+                    .quad 0x3e15b616a423c78a
+                    .quad 0x3da162a6617cc971
+                    .quad 0x3e166391c4c06d29
+                    .quad 0x3e2d46f5c1d0c4b8
+                    .quad 0x3e2e14282df1f6d3
+                    .quad 0x3e186f47424a660d
+                    .quad 0x3e2d4c8de077753e
+                    .quad 0x3e2e0c307ed24f1c
+                    .quad 0x3e226ea18763bdd3
+                    .quad 0x3e25cad69737c933
+                    .quad 0x3e2af62599088901
+                    .quad 0x3e18c66c83d6b2d0
+                    .quad 0x3e1880ceb36fb30f
+                    .quad 0x3e2495aac6ca17a4
+                    .quad 0x3e2761db4210878c
+                    .quad 0x3e2eb78e862bac2f
+                    .quad 0x3e19b2cd75790dd9
+                    .quad 0x3e2c55e5cbd3d50f
+                    .quad 0x3db162a6617cc971
+                    .quad 0x3dfdbeabaaa2e519
+                    .quad 0x3e1652cb7150c647
+                    .quad 0x3e39a11cb2cd2ee2
+                    .quad 0x3e219d0ab1a28813
+                    .quad 0x3e24bd9e80a41811
+                    .quad 0x3e3214b596faa3df
+                    .quad 0x3e303fea46980bb8
+                    .quad 0x3e31c8ffa5fd28c7
+                    .quad 0x3dce8f743bcd96c5
+                    .quad 0x3dfd98c5395315c6
+                    .quad 0x3e3996fa3ccfa7b2
+                    .quad 0x3e1cd2af2ad13037
+                    .quad 0x3e1d0da1bd17200e
+                    .quad 0x3e3330410ba68b75
+                    .quad 0x3df4f27a790e7c41
+                    .quad 0x3e13956a86f6ff1b
+                    .quad 0x3e2c6748723551d9
+                    .quad 0x3e2500de9326cdfc
+                    .quad 0x3e1086c848df1b59
+                    .quad 0x3e04357ead6836ff
+                    .quad 0x3e24832442408024
+                    .quad 0x3e3d10da8154b13d
+                    .quad 0x3e39e8ad68ec8260
+                    .quad 0x3e3cfbf706abaf18
+                    .quad 0x3e3fc56ac6326e23
+                    .quad 0x3e39105e3185cf21
+                    .quad 0x3e3d017fe5b19cc0
+                    .quad 0x3e3d1f6b48dd13fe
+                    .quad 0x3e20b63358a7e73a
+                    .quad 0x3e263063028c211c
+                    .quad 0x3e2e6a6886b09760
+                    .quad 0x3e3c138bb891cd03
+                    .quad 0x3e369f7722b7221a
+                    .quad 0x3df57d8fac1a628c
+                    .quad 0x3e3c55e5cbd3d50f
+                    .quad 0x3e1552d2ff48fe2e
+                    .quad 0x3e37b8b26ca431bc
+                    .quad 0x3e292decdc1c5f6d
+                    .quad 0x3e3abc7c551aaa8c
+                    .quad 0x3e36b540731a354b
+                    .quad 0x3e32d341036b89ef
+                    .quad 0x3e4f9ab21a3a2e0f
+                    .quad 0x3e239c871afb9fbd
+                    .quad 0x3e3e6add2c81f640
+                    .quad 0x3e435c95aa313f41
+                    .quad 0x3e249d4582f6cc53
+                    .quad 0x3e47574c1c07398f
+                    .quad 0x3e4ba846dece9e8d
+                    .quad 0x3e16999fafbc68e7
+                    .quad 0x3e4c9145e51b0103
+                    .quad 0x3e479ef2cb44850a
+                    .quad 0x3e0beec73de11275
+                    .quad 0x3e2ef4351af5a498
+                    .quad 0x3e45713a493b4a50
+                    .quad 0x3e45c23a61385992
+                    .quad 0x3e42a88309f57299
+                    .quad 0x3e4530faa9ac8ace
+                    .quad 0x3e25fec2d792a758
+                    .quad 0x3e35a517a71cbcd7
+                    .quad 0x3e3707dc3e1cd9a3
+                    .quad 0x3e3a1a9f8ef43049
+                    .quad 0x3e4409d0276b3674
+                    .quad 0x3e20e2f613e85bd9
+                    .quad 0x3df0027433001e5f
+                    .quad 0x3e35dde2836d3265
+                    .quad 0x3e2300134d7aaf04
+                    .quad 0x3e3cb7e0b42724f5
+                    .quad 0x3e2d6e93167e6308
+                    .quad 0x3e3d1569b1526adb
+                    .quad 0x3e0e99fc338a1a41
+                    .quad 0x3e4eb01394a11b1c
+                    .quad 0x3e04f27a790e7c41
+                    .quad 0x3e25ce3ca97b7af9
+                    .quad 0x3e281f0f940ed857
+                    .quad 0x3e4d36295d88857c
+                    .quad 0x3e21aca1ec4af526
+                    .quad 0x3e445743c7182726
+                    .quad 0x3e23c491aead337e
+                    .quad 0x3e3aef401a738931
+                    .quad 0x3e21cede76092a29
+                    .quad 0x3e4fba8f44f82bb4
+                    .quad 0x3e446f5f7f3c3e1a
+                    .quad 0x3e47055f86c9674b
+                    .quad 0x3e4b41a92b6b6e1a
+                    .quad 0x3e443d162e927628
+                    .quad 0x3e4466174013f9b1
+                    .quad 0x3e3b05096ad69c62
+                    .quad 0x3e40b169150faa58
+                    .quad 0x3e3cd98b1df85da7
+                    .quad 0x3e468b507b0f8fa8
+                    .quad 0x3e48422df57499ba
+                    .quad 0x3e11351586970274
+                    .quad 0x3e117e08acba92ee
+                    .quad 0x3e26e04314dd0229
+                    .quad 0x3e497f3097e56d1a
+                    .quad 0x3e3356e655901286
+                    .quad 0x3e0cb761457f94d6
+                    .quad 0x3e39af67a85a9dac
+                    .quad 0x3e453410931a909f
+                    .quad 0x3e22c587206058f5
+                    .quad 0x3e223bc358899c22
+                    .quad 0x3e4d7bf8b6d223cb
+                    .quad 0x3e47991ec5197ddb
+                    .quad 0x3e4a79e6bb3a9219
+                    .quad 0x3e3a4c43ed663ec5
+                    .quad 0x3e461b5a1484f438
+                    .quad 0x3e4b4e36f7ef0c3a
+                    .quad 0x3e115f026acd0d1b
+                    .quad 0x3e3f36b535cecf05
+                    .quad 0x3e2ffb7fbf3eb5c6
+                    .quad 0x3e3e6a6886b09760
+                    .quad 0x3e3135eb27f5bbc3
+                    .quad 0x3e470be7d6f6fa57
+                    .quad 0x3e4ce43cc84ab338
+                    .quad 0x3e4c01d7aac3bd91
+                    .quad 0x3e45c58d07961060
+                    .quad 0x3e3628bcf941456e
+                    .quad 0x3e4c58b2a8461cd2
+                    .quad 0x3e33071282fb989a
+                    .quad 0x3e420dab6a80f09c
+                    .quad 0x3e44f8d84c397b1e
+                    .quad 0x3e40d0ee08599e48
+                    .quad 0x3e1d68787e37da36
+                    .quad 0x3e366187d591bafc
+                    .quad 0x3e22346600bae772
+                    .quad 0x3e390377d0d61b8e
+                    .quad 0x3e4f5e0dd966b907
+                    .quad 0x3e49023cb79a00e2
+                    .quad 0x3e44e05158c28ad8
+                    .quad 0x3e3bfa7b08b18ae4
+                    .quad 0x3e4ef1e63db35f67
+                    .quad 0x3e0ec2ae39493d4f
+                    .quad 0x3e40afe930ab2fa0
+                    .quad 0x3e225ff8a1810dd4
+                    .quad 0x3e469743fb1a71a5
+                    .quad 0x3e5f9cc676785571
+                    .quad 0x3e5b524da4cbf982
+                    .quad 0x3e5a4c8b381535b8
+                    .quad 0x3e5839be809caf2c
+                    .quad 0x3e50968a1cb82c13
+                    .quad 0x3e5eae6a41723fb5
+                    .quad 0x3e5d9c29a380a4db
+                    .quad 0x3e4094aa0ada625e
+                    .quad 0x3e5973ad6fc108ca
+                    .quad 0x3e4747322fdbab97
+                    .quad 0x3e593692fa9d4221
+                    .quad 0x3e5c5a992dfbc7d9
+                    .quad 0x3e4e1f33e102387a
+                    .quad 0x3e464fbef14c048c
+                    .quad 0x3e4490f513ca5e3b
+                    .quad 0x3e37a6af4d4c799d
+                    .quad 0x3e57574c1c07398f
+                    .quad 0x3e57b133417f8c1c
+                    .quad 0x3e5feb9e0c176514
+                    .quad 0x3e419f25bb3172f7
+                    .quad 0x3e45f68a7bbfb852
+                    .quad 0x3e5ee278497929f1
+                    .quad 0x3e5ccee006109d58
+                    .quad 0x3e5ce081a07bd8b3
+                    .quad 0x3e570e12981817b8
+                    .quad 0x3e292ab6d93503d0
+                    .quad 0x3e58cb7dd7c3b61e
+                    .quad 0x3e4efafd0a0b78da
+                    .quad 0x3e5e907267c4288e
+                    .quad 0x3e5d31ef96780875
+                    .quad 0x3e23430dfcd2ad50
+                    .quad 0x3e344d88d75bc1f9
+                    .quad 0x3e5bec0f055e04fc
+                    .quad 0x3e5d85611590b9ad
+                    .quad 0x3df320568e583229
+                    .quad 0x3e5a891d1772f538
+                    .quad 0x3e22edc9dabba74d
+                    .quad 0x3e4b9009a1015086
+                    .quad 0x3e52a12a8c5b1a19
+                    .quad 0x3e3a7885f0fdac85
+                    .quad 0x3e5f4ffcd43ac691
+                    .quad 0x3e52243ae2640aad
+                    .quad 0x3e546513299035d3
+                    .quad 0x3e5b39c3a62dd725
+                    .quad 0x3e5ba6dd40049f51
+                    .quad 0x3e451d1ed7177409
+                    .quad 0x3e5cb0f2fd7f5216
+                    .quad 0x3e3ab150cd4e2213
+                    .quad 0x3e5cfd7bf3193844
+                    .quad 0x3e53fff8455f1dbd
+                    .quad 0x3e5fee640b905fc9
+                    .quad 0x3e54e2adf548084c
+                    .quad 0x3e3b597adc1ecdd2
+                    .quad 0x3e4345bd096d3a75
+                    .quad 0x3e5101b9d2453c8b
+                    .quad 0x3e508ce55cc8c979
+                    .quad 0x3e5bbf017e595f71
+                    .quad 0x3e37ce733bd393dc
+                    .quad 0x3e233bb0a503f8a1
+                    .quad 0x3e30e2f613e85bd9
+                    .quad 0x3e5e67555a635b3c
+                    .quad 0x3e2ea88df73d5e8b
+                    .quad 0x3e3d17e03bda18a8
+                    .quad 0x3e5b607d76044f7e
+                    .quad 0x3e52adc4e71bc2fc
+                    .quad 0x3e5f99dc7362d1d9
+                    .quad 0x3e5473fa008e6a6a
+                    .quad 0x3e2b75bb09cb0985
+                    .quad 0x3e5ea04dd10b9aba
+                    .quad 0x3e5802d0d6979674
+                    .quad 0x3e174688ccd99094
+                    .quad 0x3e496f16abb9df22
+                    .quad 0x3e46e66df2aa374f
+                    .quad 0x3e4e66525ea4550a
+                    .quad 0x3e42d02f34f20cbd
+                    .quad 0x3e46cfce65047188
+                    .quad 0x3e39b78c842d58b8
+                    .quad 0x3e4735e624c24bc9
+                    .quad 0x3e47eba1f7dd1adf
+                    .quad 0x3e586b3e59f65355
+                    .quad 0x3e1ce38e637f1b4d
+                    .quad 0x3e58d82ec919edc7
+                    .quad 0x3e4c52648ddcfa37
+                    .quad 0x3e52482ceae1ac12
+                    .quad 0x3e55a312311aba4f
+                    .quad 0x3e411e236329f225
+                    .quad 0x3e5b48c8cd2f246c
+                    .quad 0x3e6efa39ef35793c
+                    .quad 0x0000000000000000
+
+.align 16
+.L__log_F_inv_head:
+                    .quad 0x4000000000000000
+                    .quad 0x3fffe00000000000
+                    .quad 0x3fffc00000000000
+                    .quad 0x3fffa00000000000
+                    .quad 0x3fff800000000000
+                    .quad 0x3fff600000000000
+                    .quad 0x3fff400000000000
+                    .quad 0x3fff200000000000
+                    .quad 0x3fff000000000000
+                    .quad 0x3ffee00000000000
+                    .quad 0x3ffec00000000000
+                    .quad 0x3ffea00000000000
+                    .quad 0x3ffe900000000000
+                    .quad 0x3ffe700000000000
+                    .quad 0x3ffe500000000000
+                    .quad 0x3ffe300000000000
+                    .quad 0x3ffe100000000000
+                    .quad 0x3ffe000000000000
+                    .quad 0x3ffde00000000000
+                    .quad 0x3ffdc00000000000
+                    .quad 0x3ffda00000000000
+                    .quad 0x3ffd900000000000
+                    .quad 0x3ffd700000000000
+                    .quad 0x3ffd500000000000
+                    .quad 0x3ffd400000000000
+                    .quad 0x3ffd200000000000
+                    .quad 0x3ffd000000000000
+                    .quad 0x3ffcf00000000000
+                    .quad 0x3ffcd00000000000
+                    .quad 0x3ffcb00000000000
+                    .quad 0x3ffca00000000000
+                    .quad 0x3ffc800000000000
+                    .quad 0x3ffc700000000000
+                    .quad 0x3ffc500000000000
+                    .quad 0x3ffc300000000000
+                    .quad 0x3ffc200000000000
+                    .quad 0x3ffc000000000000
+                    .quad 0x3ffbf00000000000
+                    .quad 0x3ffbd00000000000
+                    .quad 0x3ffbc00000000000
+                    .quad 0x3ffba00000000000
+                    .quad 0x3ffb900000000000
+                    .quad 0x3ffb700000000000
+                    .quad 0x3ffb600000000000
+                    .quad 0x3ffb400000000000
+                    .quad 0x3ffb300000000000
+                    .quad 0x3ffb200000000000
+                    .quad 0x3ffb000000000000
+                    .quad 0x3ffaf00000000000
+                    .quad 0x3ffad00000000000
+                    .quad 0x3ffac00000000000
+                    .quad 0x3ffaa00000000000
+                    .quad 0x3ffa900000000000
+                    .quad 0x3ffa800000000000
+                    .quad 0x3ffa600000000000
+                    .quad 0x3ffa500000000000
+                    .quad 0x3ffa400000000000
+                    .quad 0x3ffa200000000000
+                    .quad 0x3ffa100000000000
+                    .quad 0x3ffa000000000000
+                    .quad 0x3ff9e00000000000
+                    .quad 0x3ff9d00000000000
+                    .quad 0x3ff9c00000000000
+                    .quad 0x3ff9a00000000000
+                    .quad 0x3ff9900000000000
+                    .quad 0x3ff9800000000000
+                    .quad 0x3ff9700000000000
+                    .quad 0x3ff9500000000000
+                    .quad 0x3ff9400000000000
+                    .quad 0x3ff9300000000000
+                    .quad 0x3ff9200000000000
+                    .quad 0x3ff9000000000000
+                    .quad 0x3ff8f00000000000
+                    .quad 0x3ff8e00000000000
+                    .quad 0x3ff8d00000000000
+                    .quad 0x3ff8b00000000000
+                    .quad 0x3ff8a00000000000
+                    .quad 0x3ff8900000000000
+                    .quad 0x3ff8800000000000
+                    .quad 0x3ff8700000000000
+                    .quad 0x3ff8600000000000
+                    .quad 0x3ff8400000000000
+                    .quad 0x3ff8300000000000
+                    .quad 0x3ff8200000000000
+                    .quad 0x3ff8100000000000
+                    .quad 0x3ff8000000000000
+                    .quad 0x3ff7f00000000000
+                    .quad 0x3ff7e00000000000
+                    .quad 0x3ff7d00000000000
+                    .quad 0x3ff7b00000000000
+                    .quad 0x3ff7a00000000000
+                    .quad 0x3ff7900000000000
+                    .quad 0x3ff7800000000000
+                    .quad 0x3ff7700000000000
+                    .quad 0x3ff7600000000000
+                    .quad 0x3ff7500000000000
+                    .quad 0x3ff7400000000000
+                    .quad 0x3ff7300000000000
+                    .quad 0x3ff7200000000000
+                    .quad 0x3ff7100000000000
+                    .quad 0x3ff7000000000000
+                    .quad 0x3ff6f00000000000
+                    .quad 0x3ff6e00000000000
+                    .quad 0x3ff6d00000000000
+                    .quad 0x3ff6c00000000000
+                    .quad 0x3ff6b00000000000
+                    .quad 0x3ff6a00000000000
+                    .quad 0x3ff6900000000000
+                    .quad 0x3ff6800000000000
+                    .quad 0x3ff6700000000000
+                    .quad 0x3ff6600000000000
+                    .quad 0x3ff6500000000000
+                    .quad 0x3ff6400000000000
+                    .quad 0x3ff6300000000000
+                    .quad 0x3ff6200000000000
+                    .quad 0x3ff6100000000000
+                    .quad 0x3ff6000000000000
+                    .quad 0x3ff5f00000000000
+                    .quad 0x3ff5e00000000000
+                    .quad 0x3ff5d00000000000
+                    .quad 0x3ff5c00000000000
+                    .quad 0x3ff5b00000000000
+                    .quad 0x3ff5a00000000000
+                    .quad 0x3ff5900000000000
+                    .quad 0x3ff5800000000000
+                    .quad 0x3ff5800000000000
+                    .quad 0x3ff5700000000000
+                    .quad 0x3ff5600000000000
+                    .quad 0x3ff5500000000000
+                    .quad 0x3ff5400000000000
+                    .quad 0x3ff5300000000000
+                    .quad 0x3ff5200000000000
+                    .quad 0x3ff5100000000000
+                    .quad 0x3ff5000000000000
+                    .quad 0x3ff5000000000000
+                    .quad 0x3ff4f00000000000
+                    .quad 0x3ff4e00000000000
+                    .quad 0x3ff4d00000000000
+                    .quad 0x3ff4c00000000000
+                    .quad 0x3ff4b00000000000
+                    .quad 0x3ff4a00000000000
+                    .quad 0x3ff4a00000000000
+                    .quad 0x3ff4900000000000
+                    .quad 0x3ff4800000000000
+                    .quad 0x3ff4700000000000
+                    .quad 0x3ff4600000000000
+                    .quad 0x3ff4600000000000
+                    .quad 0x3ff4500000000000
+                    .quad 0x3ff4400000000000
+                    .quad 0x3ff4300000000000
+                    .quad 0x3ff4200000000000
+                    .quad 0x3ff4200000000000
+                    .quad 0x3ff4100000000000
+                    .quad 0x3ff4000000000000
+                    .quad 0x3ff3f00000000000
+                    .quad 0x3ff3e00000000000
+                    .quad 0x3ff3e00000000000
+                    .quad 0x3ff3d00000000000
+                    .quad 0x3ff3c00000000000
+                    .quad 0x3ff3b00000000000
+                    .quad 0x3ff3b00000000000
+                    .quad 0x3ff3a00000000000
+                    .quad 0x3ff3900000000000
+                    .quad 0x3ff3800000000000
+                    .quad 0x3ff3800000000000
+                    .quad 0x3ff3700000000000
+                    .quad 0x3ff3600000000000
+                    .quad 0x3ff3500000000000
+                    .quad 0x3ff3500000000000
+                    .quad 0x3ff3400000000000
+                    .quad 0x3ff3300000000000
+                    .quad 0x3ff3200000000000
+                    .quad 0x3ff3200000000000
+                    .quad 0x3ff3100000000000
+                    .quad 0x3ff3000000000000
+                    .quad 0x3ff3000000000000
+                    .quad 0x3ff2f00000000000
+                    .quad 0x3ff2e00000000000
+                    .quad 0x3ff2e00000000000
+                    .quad 0x3ff2d00000000000
+                    .quad 0x3ff2c00000000000
+                    .quad 0x3ff2b00000000000
+                    .quad 0x3ff2b00000000000
+                    .quad 0x3ff2a00000000000
+                    .quad 0x3ff2900000000000
+                    .quad 0x3ff2900000000000
+                    .quad 0x3ff2800000000000
+                    .quad 0x3ff2700000000000
+                    .quad 0x3ff2700000000000
+                    .quad 0x3ff2600000000000
+                    .quad 0x3ff2500000000000
+                    .quad 0x3ff2500000000000
+                    .quad 0x3ff2400000000000
+                    .quad 0x3ff2300000000000
+                    .quad 0x3ff2300000000000
+                    .quad 0x3ff2200000000000
+                    .quad 0x3ff2100000000000
+                    .quad 0x3ff2100000000000
+                    .quad 0x3ff2000000000000
+                    .quad 0x3ff2000000000000
+                    .quad 0x3ff1f00000000000
+                    .quad 0x3ff1e00000000000
+                    .quad 0x3ff1e00000000000
+                    .quad 0x3ff1d00000000000
+                    .quad 0x3ff1c00000000000
+                    .quad 0x3ff1c00000000000
+                    .quad 0x3ff1b00000000000
+                    .quad 0x3ff1b00000000000
+                    .quad 0x3ff1a00000000000
+                    .quad 0x3ff1900000000000
+                    .quad 0x3ff1900000000000
+                    .quad 0x3ff1800000000000
+                    .quad 0x3ff1800000000000
+                    .quad 0x3ff1700000000000
+                    .quad 0x3ff1600000000000
+                    .quad 0x3ff1600000000000
+                    .quad 0x3ff1500000000000
+                    .quad 0x3ff1500000000000
+                    .quad 0x3ff1400000000000
+                    .quad 0x3ff1300000000000
+                    .quad 0x3ff1300000000000
+                    .quad 0x3ff1200000000000
+                    .quad 0x3ff1200000000000
+                    .quad 0x3ff1100000000000
+                    .quad 0x3ff1100000000000
+                    .quad 0x3ff1000000000000
+                    .quad 0x3ff0f00000000000
+                    .quad 0x3ff0f00000000000
+                    .quad 0x3ff0e00000000000
+                    .quad 0x3ff0e00000000000
+                    .quad 0x3ff0d00000000000
+                    .quad 0x3ff0d00000000000
+                    .quad 0x3ff0c00000000000
+                    .quad 0x3ff0c00000000000
+                    .quad 0x3ff0b00000000000
+                    .quad 0x3ff0a00000000000
+                    .quad 0x3ff0a00000000000
+                    .quad 0x3ff0900000000000
+                    .quad 0x3ff0900000000000
+                    .quad 0x3ff0800000000000
+                    .quad 0x3ff0800000000000
+                    .quad 0x3ff0700000000000
+                    .quad 0x3ff0700000000000
+                    .quad 0x3ff0600000000000
+                    .quad 0x3ff0600000000000
+                    .quad 0x3ff0500000000000
+                    .quad 0x3ff0500000000000
+                    .quad 0x3ff0400000000000
+                    .quad 0x3ff0400000000000
+                    .quad 0x3ff0300000000000
+                    .quad 0x3ff0300000000000
+                    .quad 0x3ff0200000000000
+                    .quad 0x3ff0200000000000
+                    .quad 0x3ff0100000000000
+                    .quad 0x3ff0100000000000
+                    .quad 0x3ff0000000000000
+                    .quad 0x3ff0000000000000
+
+.align 16
+.L__log_F_inv_tail:
+                    .quad 0x0000000000000000
+                    .quad 0x3effe01fe01fe020
+                    .quad 0x3f1fc07f01fc07f0
+                    .quad 0x3f31caa01fa11caa
+                    .quad 0x3f3f81f81f81f820
+                    .quad 0x3f48856506ddaba6
+                    .quad 0x3f5196792909c560
+                    .quad 0x3f57d9108c2ad433
+                    .quad 0x3f5f07c1f07c1f08
+                    .quad 0x3f638ff08b1c03dd
+                    .quad 0x3f680f6603d980f6
+                    .quad 0x3f6d00f57403d5d0
+                    .quad 0x3f331abf0b7672a0
+                    .quad 0x3f506a965d43919b
+                    .quad 0x3f5ceb240795ceb2
+                    .quad 0x3f6522f3b834e67f
+                    .quad 0x3f6c3c3c3c3c3c3c
+                    .quad 0x3f3e01e01e01e01e
+                    .quad 0x3f575b8fe21a291c
+                    .quad 0x3f6403b9403b9404
+                    .quad 0x3f6cc0ed7303b5cc
+                    .quad 0x3f479118f3fc4da2
+                    .quad 0x3f5ed952e0b0ce46
+                    .quad 0x3f695900eae56404
+                    .quad 0x3f3d41d41d41d41d
+                    .quad 0x3f5cb28ff16c69ae
+                    .quad 0x3f696b1edd80e866
+                    .quad 0x3f4372e225fe30d9
+                    .quad 0x3f60ad12073615a2
+                    .quad 0x3f6cdb2c0397cdb3
+                    .quad 0x3f52cc157b864407
+                    .quad 0x3f664cb5f7148404
+                    .quad 0x3f3c71c71c71c71c
+                    .quad 0x3f6129a21a930b84
+                    .quad 0x3f6f1e0387f1e038
+                    .quad 0x3f5ad4e4ba80709b
+                    .quad 0x3f6c0e070381c0e0
+                    .quad 0x3f560fba1a362bb0
+                    .quad 0x3f6a5713280dee96
+                    .quad 0x3f53f59620f9ece9
+                    .quad 0x3f69f22983759f23
+                    .quad 0x3f5478ac63fc8d5c
+                    .quad 0x3f6ad87bb4671656
+                    .quad 0x3f578b8efbb8148c
+                    .quad 0x3f6d0369d0369d03
+                    .quad 0x3f5d212b601b3748
+                    .quad 0x3f0b2036406c80d9
+                    .quad 0x3f629663b24547d1
+                    .quad 0x3f4435e50d79435e
+                    .quad 0x3f67d0ff2920bc03
+                    .quad 0x3f55c06b15c06b16
+                    .quad 0x3f6e3a5f0fd7f954
+                    .quad 0x3f61dec0d4c77b03
+                    .quad 0x3f473289870ac52e
+                    .quad 0x3f6a034da034da03
+                    .quad 0x3f5d041da2292856
+                    .quad 0x3f3a41a41a41a41a
+                    .quad 0x3f68550f8a39409d
+                    .quad 0x3f5b4fe5e92c0686
+                    .quad 0x3f3a01a01a01a01a
+                    .quad 0x3f691d2a2067b23a
+                    .quad 0x3f5e7c5dada0b4e5
+                    .quad 0x3f468a7725080ce1
+                    .quad 0x3f6c49d4aa21b490
+                    .quad 0x3f63333333333333
+                    .quad 0x3f54bc363b03fccf
+                    .quad 0x3f2c9f01970e4f81
+                    .quad 0x3f697617c6ef5b25
+                    .quad 0x3f6161f9add3c0ca
+                    .quad 0x3f5319fe6cb39806
+                    .quad 0x3f2f693a1c451ab3
+                    .quad 0x3f6a9e240321a9e2
+                    .quad 0x3f63831f3831f383
+                    .quad 0x3f5949ebc4dcfc1c
+                    .quad 0x3f480c6980c6980c
+                    .quad 0x3f6f9d00c5fe7403
+                    .quad 0x3f69721ed7e75347
+                    .quad 0x3f6381ec0313381f
+                    .quad 0x3f5b97c2aec12653
+                    .quad 0x3f509ef3024ae3ba
+                    .quad 0x3f38618618618618
+                    .quad 0x3f6e0184f00c2780
+                    .quad 0x3f692ef5657dba52
+                    .quad 0x3f64940305494030
+                    .quad 0x3f60303030303030
+                    .quad 0x3f58060180601806
+                    .quad 0x3f5017f405fd017f
+                    .quad 0x3f412a8ad278e8dd
+                    .quad 0x3f17d05f417d05f4
+                    .quad 0x3f6d67245c02f7d6
+                    .quad 0x3f6a4411c1d986a9
+                    .quad 0x3f6754d76c7316df
+                    .quad 0x3f649902f149902f
+                    .quad 0x3f621023358c1a68
+                    .quad 0x3f5f7390d2a6c406
+                    .quad 0x3f5b2b0805d5b2b1
+                    .quad 0x3f5745d1745d1746
+                    .quad 0x3f53c31507fa32c4
+                    .quad 0x3f50a1fd1b7af017
+                    .quad 0x3f4bc36ce3e0453a
+                    .quad 0x3f4702e05c0b8170
+                    .quad 0x3f4300b79300b793
+                    .quad 0x3f3f76b4337c6cb1
+                    .quad 0x3f3a62681c860fb0
+                    .quad 0x3f36c16c16c16c17
+                    .quad 0x3f3490aa31a3cfc7
+                    .quad 0x3f33cd153729043e
+                    .quad 0x3f3473a88d0bfd2e
+                    .quad 0x3f36816816816817
+                    .quad 0x3f39f36016719f36
+                    .quad 0x3f3ec6a5122f9016
+                    .quad 0x3f427c29da5519cf
+                    .quad 0x3f4642c8590b2164
+                    .quad 0x3f4ab5c45606f00b
+                    .quad 0x3f4fd3b80b11fd3c
+                    .quad 0x3f52cda0c6ba4eaa
+                    .quad 0x3f56058160581606
+                    .quad 0x3f5990d0a4b7ef87
+                    .quad 0x3f5d6ee340579d6f
+                    .quad 0x3f60cf87d9c54a69
+                    .quad 0x3f6310572620ae4c
+                    .quad 0x3f65798c8ff522a2
+                    .quad 0x3f680ad602b580ad
+                    .quad 0x3f6ac3e24799546f
+                    .quad 0x3f6da46102b1da46
+                    .quad 0x3f15805601580560
+                    .quad 0x3f3ed3c506b39a23
+                    .quad 0x3f4cbdd3e2970f60
+                    .quad 0x3f55555555555555
+                    .quad 0x3f5c979aee0bf805
+                    .quad 0x3f621291e81fd58e
+                    .quad 0x3f65fead500a9580
+                    .quad 0x3f6a0fd5c5f02a3a
+                    .quad 0x3f6e45c223898adc
+                    .quad 0x3f35015015015015
+                    .quad 0x3f4c7b16ea64d422
+                    .quad 0x3f57829cbc14e5e1
+                    .quad 0x3f60877db8589720
+                    .quad 0x3f65710e4b5edcea
+                    .quad 0x3f6a7dbb4d1fc1c8
+                    .quad 0x3f6fad40a57eb503
+                    .quad 0x3f43fd6bb00a5140
+                    .quad 0x3f54e78ecb419ba9
+                    .quad 0x3f600a44029100a4
+                    .quad 0x3f65c28f5c28f5c3
+                    .quad 0x3f6b9c68b2c0cc4a
+                    .quad 0x3f2978feb9f34381
+                    .quad 0x3f4ecf163bb6500a
+                    .quad 0x3f5be1958b67ebb9
+                    .quad 0x3f644e6157dc9a3b
+                    .quad 0x3f6acc4baa3f0ddf
+                    .quad 0x3f26a4cbcb2a247b
+                    .quad 0x3f50505050505050
+                    .quad 0x3f5e0b4439959819
+                    .quad 0x3f66027f6027f602
+                    .quad 0x3f6d1e854b5e0db4
+                    .quad 0x3f4165e7254813e2
+                    .quad 0x3f576646a9d716ef
+                    .quad 0x3f632b48f757ce88
+                    .quad 0x3f6ac1b24652a906
+                    .quad 0x3f33b13b13b13b14
+                    .quad 0x3f5490e1eb208984
+                    .quad 0x3f62385830fec66e
+                    .quad 0x3f6a45a6cc111b7e
+                    .quad 0x3f33813813813814
+                    .quad 0x3f556f472517b708
+                    .quad 0x3f631be7bc0e8f2a
+                    .quad 0x3f6b9cbf3e55f044
+                    .quad 0x3f40e7d95bc609a9
+                    .quad 0x3f59e6b3804d19e7
+                    .quad 0x3f65c8b6af7963c2
+                    .quad 0x3f6eb9dad43bf402
+                    .quad 0x3f4f1a515885fb37
+                    .quad 0x3f60eeb1d3d76c02
+                    .quad 0x3f6a320261a32026
+                    .quad 0x3f3c82ac40260390
+                    .quad 0x3f5a12f684bda12f
+                    .quad 0x3f669d43fda2962c
+                    .quad 0x3f02e025c04b8097
+                    .quad 0x3f542804b542804b
+                    .quad 0x3f63f69b02593f6a
+                    .quad 0x3f6df31cb46e21fa
+                    .quad 0x3f5012b404ad012b
+                    .quad 0x3f623925e7820a7f
+                    .quad 0x3f6c8253c8253c82
+                    .quad 0x3f4b92ddc02526e5
+                    .quad 0x3f61602511602511
+                    .quad 0x3f6bf471439c9adf
+                    .quad 0x3f4a85c40939a85c
+                    .quad 0x3f6166f9ac024d16
+                    .quad 0x3f6c44e10125e227
+                    .quad 0x3f4cebf48bbd90e5
+                    .quad 0x3f62492492492492
+                    .quad 0x3f6d6f2e2ec0b673
+                    .quad 0x3f5159e26af37c05
+                    .quad 0x3f64024540245402
+                    .quad 0x3f6f6f0243f6f024
+                    .quad 0x3f55e60121579805
+                    .quad 0x3f668e18cf81b10f
+                    .quad 0x3f32012012012012
+                    .quad 0x3f5c11f7047dc11f
+                    .quad 0x3f69e878ff70985e
+                    .quad 0x3f4779d9fdc3a219
+                    .quad 0x3f61eace5c957907
+                    .quad 0x3f6e0d5b450239e1
+                    .quad 0x3f548bf073816367
+                    .quad 0x3f6694808dda5202
+                    .quad 0x3f37c67f2bae2b21
+                    .quad 0x3f5ee58469ee5847
+                    .quad 0x3f6c0233c0233c02
+                    .quad 0x3f514e02328a7012
+                    .quad 0x3f6561072057b573
+                    .quad 0x3f31811811811812
+                    .quad 0x3f5e28646f5a1060
+                    .quad 0x3f6c0d1284e6f1d7
+                    .quad 0x3f523543f0c80459
+                    .quad 0x3f663cbeea4e1a09
+                    .quad 0x3f3b9a3fdd5c8cb8
+                    .quad 0x3f60be1c159a76d2
+                    .quad 0x3f6e1d1a688e4838
+                    .quad 0x3f572044d72044d7
+                    .quad 0x3f691713db81577b
+                    .quad 0x3f4ac73ae9819b50
+                    .quad 0x3f6460334e904cf6
+                    .quad 0x3f31111111111111
+                    .quad 0x3f5feef80441fef0
+                    .quad 0x3f6de021fde021fe
+                    .quad 0x3f57b7eacc9686a0
+                    .quad 0x3f69ead7cd391fbc
+                    .quad 0x3f50195609804390
+                    .quad 0x3f6641511e8d2b32
+                    .quad 0x3f4222b1acf1ce96
+                    .quad 0x3f62e29f79b47582
+                    .quad 0x3f24f0d1682e11cd
+                    .quad 0x3f5f9bb096771e4d
+                    .quad 0x3f6e5ee45dd96ae2
+                    .quad 0x3f5a0429a0429a04
+                    .quad 0x3f6bb74d5f06c021
+                    .quad 0x3f54fce404254fce
+                    .quad 0x3f695766eacbc402
+                    .quad 0x3f50842108421084
+                    .quad 0x3f673e5371d5c338
+                    .quad 0x3f4930523fbe3368
+                    .quad 0x3f656b38f225f6c4
+                    .quad 0x3f426e978d4fdf3b
+                    .quad 0x3f63dd40e4eb0cc6
+                    .quad 0x3f397f7d73404146
+                    .quad 0x3f6293982cc98af1
+                    .quad 0x3f30410410410410
+                    .quad 0x3f618d6f048ff7e4
+                    .quad 0x3f2236a3ebc349de
+                    .quad 0x3f60c9f8ee53d18c
+                    .quad 0x3f10204081020408
+                    .quad 0x3f60486ca2f46ea6
+                    .quad 0x3ef0101010101010
+                    .quad 0x3f60080402010080
+                    .quad 0x0000000000000000
+
+#---------------------
+# exp data
+#---------------------
+
+.align 16
+
+.L__denormal_threshold:         .long 0x0fffffc02 # -1022
+                                .long 0
+                                .quad 0
+
+.L__enable_almost_inf:          .quad 0x7fe0000000000000
+                                .quad 0
+
+.L__real_zero:                  .quad 0x0000000000000000
+                                .quad 0
+
+.L__real_smallest_denormal:     .quad 0x0000000000000001
+                                .quad 0
+.L__denormal_tiny_threshold:    .quad 0x0c0874046dfefd9d0
+                                .quad 0
+
+.L__real_p65536:                .quad 0x40f0000000000000    # 65536
+                                .quad 0
+.L__real_m68800:                .quad 0x0c0f0cc0000000000   # -68800
+                                .quad 0
+.L__real_64_by_log2:            .quad 0x40571547652b82fe    # 64/ln(2)
+                                .quad 0
+.L__real_log2_by_64_head:       .quad 0x3f862e42f0000000    # log2_by_64_head
+                                .quad 0
+.L__real_log2_by_64_tail:       .quad 0x0bdfdf473de6af278   # -log2_by_64_tail
+                                .quad 0
+.L__real_1_by_720:              .quad 0x3f56c16c16c16c17    # 1/720
+                                .quad 0
+.L__real_1_by_120:              .quad 0x3f81111111111111    # 1/120
+                                .quad 0
+.L__real_1_by_24:               .quad 0x3fa5555555555555    # 1/24
+                                .quad 0
+.L__real_1_by_6:                .quad 0x3fc5555555555555    # 1/6
+                                .quad 0
+.L__real_1_by_2:                .quad 0x3fe0000000000000    # 1/2
+                                .quad 0
+
+.align 16
+.L__two_to_jby64_head_table:
+    .quad 0x3ff0000000000000
+    .quad 0x3ff02c9a30000000
+    .quad 0x3ff059b0d0000000
+    .quad 0x3ff0874510000000
+    .quad 0x3ff0b55860000000
+    .quad 0x3ff0e3ec30000000
+    .quad 0x3ff11301d0000000
+    .quad 0x3ff1429aa0000000
+    .quad 0x3ff172b830000000
+    .quad 0x3ff1a35be0000000
+    .quad 0x3ff1d48730000000
+    .quad 0x3ff2063b80000000
+    .quad 0x3ff2387a60000000
+    .quad 0x3ff26b4560000000
+    .quad 0x3ff29e9df0000000
+    .quad 0x3ff2d285a0000000
+    .quad 0x3ff306fe00000000
+    .quad 0x3ff33c08b0000000
+    .quad 0x3ff371a730000000
+    .quad 0x3ff3a7db30000000
+    .quad 0x3ff3dea640000000
+    .quad 0x3ff4160a20000000
+    .quad 0x3ff44e0860000000
+    .quad 0x3ff486a2b0000000
+    .quad 0x3ff4bfdad0000000
+    .quad 0x3ff4f9b270000000
+    .quad 0x3ff5342b50000000
+    .quad 0x3ff56f4730000000
+    .quad 0x3ff5ab07d0000000
+    .quad 0x3ff5e76f10000000
+    .quad 0x3ff6247eb0000000
+    .quad 0x3ff6623880000000
+    .quad 0x3ff6a09e60000000
+    .quad 0x3ff6dfb230000000
+    .quad 0x3ff71f75e0000000
+    .quad 0x3ff75feb50000000
+    .quad 0x3ff7a11470000000
+    .quad 0x3ff7e2f330000000
+    .quad 0x3ff8258990000000
+    .quad 0x3ff868d990000000
+    .quad 0x3ff8ace540000000
+    .quad 0x3ff8f1ae90000000
+    .quad 0x3ff93737b0000000
+    .quad 0x3ff97d8290000000
+    .quad 0x3ff9c49180000000
+    .quad 0x3ffa0c6670000000
+    .quad 0x3ffa5503b0000000
+    .quad 0x3ffa9e6b50000000
+    .quad 0x3ffae89f90000000
+    .quad 0x3ffb33a2b0000000
+    .quad 0x3ffb7f76f0000000
+    .quad 0x3ffbcc1e90000000
+    .quad 0x3ffc199bd0000000
+    .quad 0x3ffc67f120000000
+    .quad 0x3ffcb720d0000000
+    .quad 0x3ffd072d40000000
+    .quad 0x3ffd5818d0000000
+    .quad 0x3ffda9e600000000
+    .quad 0x3ffdfc9730000000
+    .quad 0x3ffe502ee0000000
+    .quad 0x3ffea4afa0000000
+    .quad 0x3ffefa1be0000000
+    .quad 0x3fff507650000000
+    .quad 0x3fffa7c180000000
+
+.align 16
+.L__two_to_jby64_tail_table:
+    .quad 0x0000000000000000
+    .quad 0x3e6cef00c1dcdef9
+    .quad 0x3e48ac2ba1d73e2a
+    .quad 0x3e60eb37901186be
+    .quad 0x3e69f3121ec53172
+    .quad 0x3e469e8d10103a17
+    .quad 0x3df25b50a4ebbf1a
+    .quad 0x3e6d525bbf668203
+    .quad 0x3e68faa2f5b9bef9
+    .quad 0x3e66df96ea796d31
+    .quad 0x3e368b9aa7805b80
+    .quad 0x3e60c519ac771dd6
+    .quad 0x3e6ceac470cd83f5
+    .quad 0x3e5789f37495e99c
+    .quad 0x3e547f7b84b09745
+    .quad 0x3e5b900c2d002475
+    .quad 0x3e64636e2a5bd1ab
+    .quad 0x3e4320b7fa64e430
+    .quad 0x3e5ceaa72a9c5154
+    .quad 0x3e53967fdba86f24
+    .quad 0x3e682468446b6824
+    .quad 0x3e3f72e29f84325b
+    .quad 0x3e18624b40c4dbd0
+    .quad 0x3e5704f3404f068e
+    .quad 0x3e54d8a89c750e5e
+    .quad 0x3e5a74b29ab4cf62
+    .quad 0x3e5a753e077c2a0f
+    .quad 0x3e5ad49f699bb2c0
+    .quad 0x3e6a90a852b19260
+    .quad 0x3e56b48521ba6f93
+    .quad 0x3e0d2ac258f87d03
+    .quad 0x3e42a91124893ecf
+    .quad 0x3e59fcef32422cbe
+    .quad 0x3e68ca345de441c5
+    .quad 0x3e61d8bee7ba46e1
+    .quad 0x3e59099f22fdba6a
+    .quad 0x3e4f580c36bea881
+    .quad 0x3e5b3d398841740a
+    .quad 0x3e62999c25159f11
+    .quad 0x3e668925d901c83b
+    .quad 0x3e415506dadd3e2a
+    .quad 0x3e622aee6c57304e
+    .quad 0x3e29b8bc9e8a0387
+    .quad 0x3e6fbc9c9f173d24
+    .quad 0x3e451f8480e3e235
+    .quad 0x3e66bbcac96535b5
+    .quad 0x3e41f12ae45a1224
+    .quad 0x3e55e7f6fd0fac90
+    .quad 0x3e62b5a75abd0e69
+    .quad 0x3e609e2bf5ed7fa1
+    .quad 0x3e47daf237553d84
+    .quad 0x3e12f074891ee83d
+    .quad 0x3e6b0aa538444196
+    .quad 0x3e6cafa29694426f
+    .quad 0x3e69df20d22a0797
+    .quad 0x3e640f12f71a1e45
+    .quad 0x3e69f7490e4bb40b
+    .quad 0x3e4ed9942b84600d
+    .quad 0x3e4bdcdaf5cb4656
+    .quad 0x3e5e2cffd89cf44c
+    .quad 0x3e452486cc2c7b9d
+    .quad 0x3e6cc2b44eee3fa4
+    .quad 0x3e66dc8a80ce9f09
+    .quad 0x3e39e90d82e90a7e
+
+
+#endif
diff --git a/src/gas/powf.S b/src/gas/powf.S
new file mode 100644
index 0000000..96eefd2
--- /dev/null
+++ b/src/gas/powf.S
@@ -0,0 +1,1040 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+# powf.S
+#
+# An implementation of the powf libm function.
+#
+# Prototype:
+#
+#     float powf(float x, float y);
+#
+
+#
+#   Algorithm:
+#       x^y = e^(y*ln(x))
+#
+#       Look in exp, log for the respective algorithms
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(powf)
+#define fname_special _powf_special@PLT
+
+
+# local variable storage offsets
+.equ    save_x, 0x0
+.equ    save_y, 0x10
+.equ    p_temp_exp, 0x20
+.equ    negate_result, 0x30
+.equ    save_ax, 0x40
+.equ    y_head, 0x50
+.equ    p_temp_log, 0x60
+.equ    stack_size, 0x78
+
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+
+    sub         $stack_size, %rsp
+
+    movss       %xmm0, save_x(%rsp)
+    movss       %xmm1, save_y(%rsp)
+
+    mov         save_x(%rsp), %edx
+    mov         save_y(%rsp), %r8d
+
+    mov         .L__f32_exp_mant_mask(%rip), %r10d
+    and         %r8d, %r10d
+    jz          .L__y_is_zero
+
+    cmp         .L__f32_pos_one(%rip), %r8d
+    je          .L__y_is_one
+
+    mov         .L__f32_sign_mask(%rip), %r9d
+    and         %edx, %r9d
+    cmp         .L__f32_sign_mask(%rip), %r9d
+    mov         .L__f32_pos_zero(%rip), %eax
+    mov         %eax, negate_result(%rsp)    
+    je          .L__x_is_neg
+
+    cmp         .L__f32_pos_one(%rip), %edx
+    je          .L__x_is_pos_one
+
+    cmp         .L__f32_pos_zero(%rip), %edx
+    je          .L__x_is_zero
+
+    mov         .L__f32_exp_mask(%rip), %r9d
+    and         %edx, %r9d
+    cmp         .L__f32_exp_mask(%rip), %r9d
+    je          .L__x_is_inf_or_nan
+   
+    mov         .L__f32_exp_mask(%rip), %r10d
+    and         %r8d, %r10d
+    cmp         .L__f32_ay_max_bound(%rip), %r10d
+    jg          .L__ay_is_very_large
+
+    mov         .L__f32_exp_mask(%rip), %r10d
+    and         %r8d, %r10d
+    cmp         .L__f32_ay_min_bound(%rip), %r10d
+    jl          .L__ay_is_very_small
+
+    # -----------------------------
+    # compute log(x) here
+    # -----------------------------
+.L__log_x:
+
+    movss       save_y(%rsp), %xmm7
+    cvtss2sd    %xmm0, %xmm0
+    cvtss2sd    %xmm7, %xmm7
+    movsd       %xmm7, save_y(%rsp)
+
+    # compute exponent part
+    xor         %r8, %r8
+    movdqa      %xmm0, %xmm3
+    psrlq       $52, %xmm3
+    movd        %xmm0, %r8
+    psubq       .L__mask_1023(%rip), %xmm3
+    movdqa      %xmm0, %xmm2
+    cvtdq2pd    %xmm3, %xmm6 # xexp
+    pand        .L__real_mant(%rip), %xmm2
+
+    # compute index into the log tables
+    mov         %r8, %r9
+    and         .L__mask_mant_all7(%rip), %r8
+    and         .L__mask_mant8(%rip), %r9
+    shl         %r9
+    add         %r9, %r8
+    mov         %r8, p_temp_log(%rsp)
+
+    # F, Y
+    movsd       p_temp_log(%rsp), %xmm1
+    shr         $45, %r8
+    por         .L__real_half(%rip), %xmm2
+    por         .L__real_half(%rip), %xmm1
+    lea         .L__log_F_inv(%rip), %r9
+
+    # f = F - Y, r = f * inv
+    subsd       %xmm2, %xmm1
+    mulsd       (%r9,%r8,8), %xmm1
+    movsd       %xmm1, %xmm2
+
+    lea         .L__log_128_table(%rip), %r9
+    movsd       .L__real_log2(%rip), %xmm5
+    movsd       (%r9,%r8,8), %xmm0
+
+    # poly
+    mulsd       %xmm2, %xmm1
+    movsd       .L__real_1_over_4(%rip), %xmm4
+    movsd       .L__real_1_over_2(%rip), %xmm3
+    mulsd       %xmm2, %xmm4
+    mulsd       %xmm2, %xmm3
+    mulsd       %xmm2, %xmm1
+    addsd       .L__real_1_over_3(%rip), %xmm4
+    addsd       .L__real_1_over_1(%rip), %xmm3
+    mulsd       %xmm1, %xmm4
+    mulsd       %xmm2, %xmm3
+    addsd       %xmm4, %xmm3  
+
+    mulsd       %xmm6, %xmm5
+    subsd       %xmm3, %xmm0
+    addsd       %xmm5, %xmm0
+
+    movsd       save_y(%rsp), %xmm7
+    mulsd       %xmm7, %xmm0
+ 
+    # v = y * ln(x)
+    # xmm0 - v
+
+    # -----------------------------
+    # compute exp( y * ln(x) ) here
+    # -----------------------------
+
+    # x * (32/ln(2))
+    movsd       .L__real_32_by_log2(%rip), %xmm7
+    movsd       %xmm0, p_temp_exp(%rsp)
+    mulsd       %xmm0, %xmm7
+    mov         p_temp_exp(%rsp), %rdx
+
+    # v < 128*ln(2), ( v * (32/ln(2)) ) < 32*128
+    # v >= -150*ln(2), ( v * (32/ln(2)) ) >= 32*(-150)
+    comisd      .L__real_p4096(%rip), %xmm7
+    jae         .L__process_result_inf
+
+    comisd      .L__real_m4768(%rip), %xmm7
+    jb          .L__process_result_zero
+
+    # n = int( v * (32/ln(2)) )
+    cvtpd2dq    %xmm7, %xmm4
+    lea         .L__two_to_jby32_table(%rip), %r10
+    cvtdq2pd    %xmm4, %xmm1
+
+    # r = x - n * ln(2)/32
+    movsd       .L__real_log2_by_32(%rip), %xmm2
+    mulsd       %xmm1, %xmm2
+    movd        %xmm4, %ecx
+    mov         $0x1f, %rax
+    and         %ecx, %eax
+    subsd       %xmm2, %xmm0
+    movsd       %xmm0, %xmm1
+
+    # m = (n - j) / 32
+    sub         %eax, %ecx
+    sar         $5, %ecx
+
+    # q
+    mulsd       %xmm0, %xmm1
+    movsd       .L__real_1_by_24(%rip), %xmm4
+    movsd       .L__real_1_by_2(%rip), %xmm3
+    mulsd       %xmm0, %xmm4
+    mulsd       %xmm0, %xmm3
+    mulsd       %xmm0, %xmm1
+    addsd       .L__real_1_by_6(%rip), %xmm4
+    addsd       .L__real_1_by_1(%rip), %xmm3
+    mulsd       %xmm1, %xmm4
+    mulsd       %xmm0, %xmm3
+    addsd       %xmm4, %xmm3  
+    movsd       %xmm3, %xmm0
+
+    add         $1023, %rcx
+    shl         $52, %rcx
+
+    # (f)*(1+q)
+    movsd       (%r10,%rax,8), %xmm1
+    mulsd       %xmm1, %xmm0
+    addsd       %xmm1, %xmm0
+
+    mov         %rcx, p_temp_exp(%rsp)
+    mulsd       p_temp_exp(%rsp), %xmm0
+    cvtsd2ss    %xmm0, %xmm0
+    orps        negate_result(%rsp), %xmm0
+
+.L__final_check:
+    add         $stack_size, %rsp
+    ret
+
+.p2align 4,,15
+.L__process_result_zero:
+    mov         .L__f32_real_zero(%rip), %r11d
+    or          negate_result(%rsp), %r11d
+    jmp         .L__z_is_zero_or_inf
+ 
+.p2align 4,,15
+.L__process_result_inf:
+    mov         .L__f32_real_inf(%rip), %r11d
+    or          negate_result(%rsp), %r11d
+    jmp         .L__z_is_zero_or_inf
+
+
+.p2align 4,,15
+.L__x_is_neg:
+
+    mov         .L__f32_exp_mask(%rip), %r10d
+    and         %r8d, %r10d
+    cmp         .L__f32_ay_max_bound(%rip), %r10d
+    jg          .L__ay_is_very_large
+
+    # determine if y is an integer
+    mov         .L__f32_exp_mant_mask(%rip), %r10d
+    and         %r8d, %r10d
+    mov         %r10d, %r11d
+    mov         .L__f32_exp_shift(%rip), %ecx
+    shr         %cl, %r10d
+    sub         .L__f32_exp_bias(%rip), %r10d
+    js          .L__x_is_neg_y_is_not_int
+   
+    mov         .L__f32_exp_mant_mask(%rip), %eax
+    and         %edx, %eax
+    mov         %eax, save_ax(%rsp)
+
+    cmp         .L__yexp_24(%rip), %r10d
+    mov         %r10d, %ecx
+    jg          .L__continue_after_y_int_check
+
+    mov         .L__f32_mant_full(%rip), %r9d
+    shr         %cl, %r9d
+    and         %r11d, %r9d
+    jnz         .L__x_is_neg_y_is_not_int
+
+    mov         .L__f32_1_before_mant(%rip), %r9d
+    shr         %cl, %r9d
+    and         %r11d, %r9d
+    jz          .L__continue_after_y_int_check
+
+    mov         .L__f32_sign_mask(%rip), %eax
+    mov         %eax, negate_result(%rsp)    
+
+.L__continue_after_y_int_check:
+
+    cmp         .L__f32_neg_zero(%rip), %edx
+    je          .L__x_is_zero
+
+    cmp         .L__f32_neg_one(%rip), %edx
+    je          .L__x_is_neg_one
+
+    mov         .L__f32_exp_mask(%rip), %r9d
+    and         %edx, %r9d
+    cmp         .L__f32_exp_mask(%rip), %r9d
+    je          .L__x_is_inf_or_nan
+   
+    movss       save_ax(%rsp), %xmm0
+    jmp         .L__log_x
+
+.p2align 4,,15
+.L__x_is_pos_one:
+    xor         %eax, %eax
+    mov         .L__f32_exp_mask(%rip), %r10d
+    and         %r8d, %r10d
+    cmp         .L__f32_exp_mask(%rip), %r10d
+    cmove       %r8d, %eax
+    mov         .L__f32_mant_mask(%rip), %r10d
+    and         %eax, %r10d
+    jz          .L__final_check
+
+    mov         .L__f32_qnan_set(%rip), %r10d
+    and         %r8d, %r10d
+    jnz         .L__final_check
+
+    movss       save_x(%rsp), %xmm0
+    movss       save_y(%rsp), %xmm1
+    movss       .L__f32_pos_one(%rip), %xmm2
+    mov         .L__flag_x_one_y_snan(%rip), %edi
+
+    call        fname_special
+    jmp         .L__final_check      
+
+.p2align 4,,15
+.L__y_is_zero:
+
+    xor         %eax, %eax
+    mov         .L__f32_exp_mask(%rip), %r9d
+    mov         .L__f32_pos_one(%rip), %r11d
+    and         %edx, %r9d
+    cmp         .L__f32_exp_mask(%rip), %r9d
+    cmove       %edx, %eax
+    mov         .L__f32_mant_mask(%rip), %r9d
+    and         %eax, %r9d
+    jnz         .L__x_is_nan
+
+    movss       .L__f32_pos_one(%rip), %xmm0
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__y_is_one:
+    xor         %eax, %eax
+    mov         %edx, %r11d
+    mov         .L__f32_exp_mask(%rip), %r9d
+    or          .L__f32_qnan_set(%rip), %r11d
+    and         %edx, %r9d
+    cmp         .L__f32_exp_mask(%rip), %r9d
+    cmove       %edx, %eax
+    mov         .L__f32_mant_mask(%rip), %r9d
+    and         %eax, %r9d
+    jnz         .L__x_is_nan
+
+    movd        %edx, %xmm0 
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__x_is_neg_one:
+    mov         .L__f32_pos_one(%rip), %edx
+    or          negate_result(%rsp), %edx
+    xor         %eax, %eax
+    mov         %r8d, %r11d
+    mov         .L__f32_exp_mask(%rip), %r10d
+    or          .L__f32_qnan_set(%rip), %r11d
+    and         %r8d, %r10d
+    cmp         .L__f32_exp_mask(%rip), %r10d
+    cmove       %r8d, %eax
+    mov         .L__f32_mant_mask(%rip), %r10d
+    and         %eax, %r10d
+    jnz         .L__y_is_nan
+
+    movd        %edx, %xmm0
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__x_is_neg_y_is_not_int:
+    mov         .L__f32_exp_mask(%rip), %r9d
+    and         %edx, %r9d
+    cmp         .L__f32_exp_mask(%rip), %r9d
+    je          .L__x_is_inf_or_nan
+
+    cmp         .L__f32_neg_zero(%rip), %edx
+    je          .L__x_is_zero
+
+    movss       save_x(%rsp), %xmm0
+    movss       save_y(%rsp), %xmm1
+    movss       .L__f32_qnan(%rip), %xmm2
+    mov         .L__flag_x_neg_y_notint(%rip), %edi
+
+    call        fname_special
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__ay_is_very_large:
+    mov         .L__f32_exp_mask(%rip), %r9d
+    and         %edx, %r9d
+    cmp         .L__f32_exp_mask(%rip), %r9d
+    je          .L__x_is_inf_or_nan
+
+    mov         .L__f32_exp_mant_mask(%rip), %r9d
+    and         %edx, %r9d
+    jz          .L__x_is_zero 
+
+    cmp         .L__f32_neg_one(%rip), %edx
+    je          .L__x_is_neg_one
+
+    mov         %edx, %r9d
+    and         .L__f32_exp_mant_mask(%rip), %r9d
+    cmp         .L__f32_pos_one(%rip), %r9d
+    jl          .L__ax_lt1_y_is_large_or_inf_or_nan
+  
+    jmp         .L__ax_gt1_y_is_large_or_inf_or_nan
+
+.p2align 4,,15
+.L__x_is_zero:
+    mov         .L__f32_exp_mask(%rip), %r10d
+    xor         %eax, %eax
+    and         %r8d, %r10d
+    cmp         .L__f32_exp_mask(%rip), %r10d
+    je          .L__x_is_zero_y_is_inf_or_nan
+
+    mov         .L__f32_sign_mask(%rip), %r10d
+    and         %r8d, %r10d
+    cmovnz      .L__f32_pos_inf(%rip), %eax
+    jnz         .L__x_is_zero_z_is_inf
+
+    movd        %eax, %xmm0
+    orps        negate_result(%rsp), %xmm0
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__x_is_zero_z_is_inf:
+
+    movss       save_x(%rsp), %xmm0
+    movss       save_y(%rsp), %xmm1
+    movd        %eax, %xmm2
+    orps        negate_result(%rsp), %xmm2
+    mov         .L__flag_x_zero_z_inf(%rip), %edi
+
+    call        fname_special
+    jmp         .L__final_check    
+
+.p2align 4,,15
+.L__x_is_zero_y_is_inf_or_nan:
+    mov         %r8d, %r11d
+    cmp         .L__f32_neg_inf(%rip), %r8d
+    cmove       .L__f32_pos_inf(%rip), %eax
+    je          .L__x_is_zero_z_is_inf
+
+    or          .L__f32_qnan_set(%rip), %r11d
+    mov         .L__f32_mant_mask(%rip), %r10d
+    and         %r8d, %r10d
+    jnz         .L__y_is_nan
+
+    movd        %eax, %xmm0
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__x_is_inf_or_nan:
+    xor         %r11d, %r11d
+    mov         .L__f32_sign_mask(%rip), %r10d
+    and         %r8d, %r10d
+    cmovz       .L__f32_pos_inf(%rip), %r11d
+    mov         %edx, %eax
+    mov         .L__f32_mant_mask(%rip), %r9d
+    or          .L__f32_qnan_set(%rip), %eax
+    and         %edx, %r9d
+    cmovnz      %eax, %r11d
+    jnz         .L__x_is_nan
+
+    xor         %eax, %eax
+    mov         %r8d, %r9d
+    mov         .L__f32_exp_mask(%rip), %r10d
+    or          .L__f32_qnan_set(%rip), %r9d
+    and         %r8d, %r10d
+    cmp         .L__f32_exp_mask(%rip), %r10d
+    cmove       %r8d, %eax
+    mov         .L__f32_mant_mask(%rip), %r10d
+    and         %eax, %r10d
+    cmovnz      %r9d, %r11d
+    jnz         .L__y_is_nan
+
+    movd        %r11d, %xmm0
+    orps        negate_result(%rsp), %xmm0
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__ay_is_very_small:
+    movss       .L__f32_pos_one(%rip), %xmm0
+    addss       %xmm1, %xmm0
+    jmp         .L__final_check
+
+
+.p2align 4,,15
+.L__ax_lt1_y_is_large_or_inf_or_nan:
+    xor         %r11d, %r11d
+    mov         .L__f32_sign_mask(%rip), %r10d
+    and         %r8d, %r10d
+    cmovnz      .L__f32_pos_inf(%rip), %r11d
+    jmp         .L__adjust_for_nan
+
+.p2align 4,,15
+.L__ax_gt1_y_is_large_or_inf_or_nan:
+    xor         %r11d, %r11d
+    mov         .L__f32_sign_mask(%rip), %r10d
+    and         %r8d, %r10d
+    cmovz       .L__f32_pos_inf(%rip), %r11d
+
+.p2align 4,,15
+.L__adjust_for_nan:
+
+    xor         %eax, %eax
+    mov         %r8d, %r9d
+    mov         .L__f32_exp_mask(%rip), %r10d
+    or          .L__f32_qnan_set(%rip), %r9d
+    and         %r8d, %r10d
+    cmp         .L__f32_exp_mask(%rip), %r10d
+    cmove       %r8d, %eax
+    mov         .L__f32_mant_mask(%rip), %r10d
+    and         %eax, %r10d
+    cmovnz      %r9d, %r11d
+    jnz         .L__y_is_nan
+
+    test        %eax, %eax
+    jnz         .L__y_is_inf
+
+.p2align 4,,15
+.L__z_is_zero_or_inf:
+
+    mov         .L__flag_z_zero(%rip), %edi
+    test        %r11d, %r11d
+    cmovnz      .L__flag_z_inf(%rip), %edi
+    
+    movss       save_x(%rsp), %xmm0
+    movss       save_y(%rsp), %xmm1
+    movd        %r11d, %xmm2
+
+    call        fname_special
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__y_is_inf:
+
+    movd        %r11d, %xmm0
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__x_is_nan:
+
+    xor         %eax, %eax
+    mov         .L__f32_exp_mask(%rip), %r10d
+    and         %r8d, %r10d
+    cmp         .L__f32_exp_mask(%rip), %r10d
+    cmove       %r8d, %eax
+    mov         .L__f32_mant_mask(%rip), %r10d
+    and         %eax, %r10d
+    jnz         .L__x_is_nan_y_is_nan
+
+    mov         .L__f32_qnan_set(%rip), %r9d
+    and         %edx, %r9d
+    movd        %r11d, %xmm0
+    jnz         .L__final_check
+
+    movss       save_x(%rsp), %xmm0
+    movss       save_y(%rsp), %xmm1
+    movd        %r11d, %xmm2
+    mov         .L__flag_x_nan(%rip), %edi
+
+    call        fname_special
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__y_is_nan:
+
+    mov         .L__f32_qnan_set(%rip), %r10d
+    and         %r8d, %r10d
+    movd        %r11d, %xmm0
+    jnz         .L__final_check
+
+    movss       save_x(%rsp), %xmm0
+    movss       save_y(%rsp), %xmm1
+    movd        %r11d, %xmm2
+    mov         .L__flag_y_nan(%rip), %edi
+
+    call        fname_special
+    jmp         .L__final_check
+
+.p2align 4,,15
+.L__x_is_nan_y_is_nan:
+
+    mov         .L__f32_qnan_set(%rip), %r9d
+    and         %edx, %r9d
+    jz          .L__continue_xy_nan
+
+    mov         .L__f32_qnan_set(%rip), %r10d
+    and         %r8d, %r10d
+    jz          .L__continue_xy_nan
+
+    movd        %r11d, %xmm0
+    jmp         .L__final_check
+
+.L__continue_xy_nan:    
+    movss       save_x(%rsp), %xmm0
+    movss       save_y(%rsp), %xmm1
+    movd        %r11d, %xmm2
+    mov         .L__flag_x_nan_y_nan(%rip), %edi
+
+    call        fname_special
+    jmp         .L__final_check  
+
+.data
+
+.align 16
+
+# these codes and the ones in the corresponding .c file have to match
+.L__flag_x_one_y_snan:          .long 1
+.L__flag_x_zero_z_inf:          .long 2
+.L__flag_x_nan:                 .long 3
+.L__flag_y_nan:                 .long 4
+.L__flag_x_nan_y_nan:           .long 5
+.L__flag_x_neg_y_notint:        .long 6
+.L__flag_z_zero:                .long 7
+.L__flag_z_denormal:            .long 8
+.L__flag_z_inf:                 .long 9
+
+.align 16
+
+.L__f32_ay_max_bound:           .long 0x4f000000
+.L__f32_ay_min_bound:           .long 0x2e800000
+.L__f32_sign_mask:              .long 0x80000000
+.L__f32_sign_and_exp_mask:      .long 0x0ff800000
+.L__f32_exp_mask:               .long 0x7f800000
+.L__f32_neg_inf:                .long 0x0ff800000
+.L__f32_pos_inf:                .long 0x7f800000
+.L__f32_pos_one:                .long 0x3f800000
+.L__f32_pos_zero:               .long 0x00000000
+.L__f32_exp_mant_mask:          .long 0x7fffffff
+.L__f32_mant_mask:              .long 0x007fffff
+
+.L__f32_neg_qnan:               .long 0x0ffc00000
+.L__f32_qnan:                   .long 0x7fc00000
+.L__f32_qnan_set:               .long 0x00400000
+
+.L__f32_neg_one:                .long 0x0bf800000
+.L__f32_neg_zero:               .long 0x80000000
+
+.L__f32_real_one:               .long 0x3f800000
+.L__f32_real_zero:              .long 0x00000000
+.L__f32_real_inf:               .long 0x7f800000
+
+.L__yexp_24:                    .long 0x00000018
+
+.L__f32_exp_shift:              .long 0x00000017
+.L__f32_exp_bias:               .long 0x0000007f
+.L__f32_mant_full:              .long 0x007fffff
+.L__f32_1_before_mant:          .long 0x00800000
+
+.align 16
+
+.L__mask_mant_all7:         .quad 0x000fe00000000000
+.L__mask_mant8:             .quad 0x0000100000000000
+
+#---------------------
+# log data
+#---------------------
+
+.align 16
+
+.L__real_ninf:  .quad 0x0fff0000000000000   # -inf
+                .quad 0x0000000000000000
+.L__real_inf:   .quad 0x7ff0000000000000    # +inf
+                .quad 0x0000000000000000
+.L__real_nan:   .quad 0x7ff8000000000000    # NaN
+                .quad 0x0000000000000000
+.L__real_mant:  .quad 0x000FFFFFFFFFFFFF    # mantissa bits
+                .quad 0x0000000000000000
+.L__mask_1023:  .quad 0x00000000000003ff
+                .quad 0x0000000000000000
+
+
+.L__real_log2:      .quad 0x3fe62e42fefa39ef
+                    .quad 0x0000000000000000
+
+.L__real_two:       .quad 0x4000000000000000 # 2
+                    .quad 0x0000000000000000
+
+.L__real_one:       .quad 0x3ff0000000000000 # 1
+                    .quad 0x0000000000000000
+
+.L__real_half:      .quad 0x3fe0000000000000 # 1/2
+                    .quad 0x0000000000000000
+
+.L__real_1_over_1:  .quad 0x3ff0000000000000
+                    .quad 0x0000000000000000
+.L__real_1_over_2:  .quad 0x3fe0000000000000
+                    .quad 0x0000000000000000
+.L__real_1_over_3:  .quad 0x3fd5555555555555
+                    .quad 0x0000000000000000
+.L__real_1_over_4:  .quad 0x3fd0000000000000
+                    .quad 0x0000000000000000
+
+
+.align 16
+.L__log_128_table:
+                    .quad 0x0000000000000000
+                    .quad 0x3f7fe02a6b106789
+                    .quad 0x3f8fc0a8b0fc03e4
+                    .quad 0x3f97b91b07d5b11b
+                    .quad 0x3f9f829b0e783300
+                    .quad 0x3fa39e87b9febd60
+                    .quad 0x3fa77458f632dcfc
+                    .quad 0x3fab42dd711971bf
+                    .quad 0x3faf0a30c01162a6
+                    .quad 0x3fb16536eea37ae1
+                    .quad 0x3fb341d7961bd1d1
+                    .quad 0x3fb51b073f06183f
+                    .quad 0x3fb6f0d28ae56b4c
+                    .quad 0x3fb8c345d6319b21
+                    .quad 0x3fba926d3a4ad563
+                    .quad 0x3fbc5e548f5bc743
+                    .quad 0x3fbe27076e2af2e6
+                    .quad 0x3fbfec9131dbeabb
+                    .quad 0x3fc0d77e7cd08e59
+                    .quad 0x3fc1b72ad52f67a0
+                    .quad 0x3fc29552f81ff523
+                    .quad 0x3fc371fc201e8f74
+                    .quad 0x3fc44d2b6ccb7d1e
+                    .quad 0x3fc526e5e3a1b438
+                    .quad 0x3fc5ff3070a793d4
+                    .quad 0x3fc6d60fe719d21d
+                    .quad 0x3fc7ab890210d909
+                    .quad 0x3fc87fa06520c911
+                    .quad 0x3fc9525a9cf456b4
+                    .quad 0x3fca23bc1fe2b563
+                    .quad 0x3fcaf3c94e80bff3
+                    .quad 0x3fcbc286742d8cd6
+                    .quad 0x3fcc8ff7c79a9a22
+                    .quad 0x3fcd5c216b4fbb91
+                    .quad 0x3fce27076e2af2e6
+                    .quad 0x3fcef0adcbdc5936
+                    .quad 0x3fcfb9186d5e3e2b
+                    .quad 0x3fd0402594b4d041
+                    .quad 0x3fd0a324e27390e3
+                    .quad 0x3fd1058bf9ae4ad5
+                    .quad 0x3fd1675cababa60e
+                    .quad 0x3fd1c898c16999fb
+                    .quad 0x3fd22941fbcf7966
+                    .quad 0x3fd2895a13de86a3
+                    .quad 0x3fd2e8e2bae11d31
+                    .quad 0x3fd347dd9a987d55
+                    .quad 0x3fd3a64c556945ea
+                    .quad 0x3fd404308686a7e4
+                    .quad 0x3fd4618bc21c5ec2
+                    .quad 0x3fd4be5f957778a1
+                    .quad 0x3fd51aad872df82d
+                    .quad 0x3fd5767717455a6c
+                    .quad 0x3fd5d1bdbf5809ca
+                    .quad 0x3fd62c82f2b9c795
+                    .quad 0x3fd686c81e9b14af
+                    .quad 0x3fd6e08eaa2ba1e4
+                    .quad 0x3fd739d7f6bbd007
+                    .quad 0x3fd792a55fdd47a2
+                    .quad 0x3fd7eaf83b82afc3
+                    .quad 0x3fd842d1da1e8b17
+                    .quad 0x3fd89a3386c1425b
+                    .quad 0x3fd8f11e873662c8
+                    .quad 0x3fd947941c2116fb
+                    .quad 0x3fd99d958117e08b
+                    .quad 0x3fd9f323ecbf984c
+                    .quad 0x3fda484090e5bb0a
+                    .quad 0x3fda9cec9a9a084a
+                    .quad 0x3fdaf1293247786b
+                    .quad 0x3fdb44f77bcc8f63
+                    .quad 0x3fdb9858969310fb
+                    .quad 0x3fdbeb4d9da71b7c
+                    .quad 0x3fdc3dd7a7cdad4d
+                    .quad 0x3fdc8ff7c79a9a22
+                    .quad 0x3fdce1af0b85f3eb
+                    .quad 0x3fdd32fe7e00ebd5
+                    .quad 0x3fdd83e7258a2f3e
+                    .quad 0x3fddd46a04c1c4a1
+                    .quad 0x3fde24881a7c6c26
+                    .quad 0x3fde744261d68788
+                    .quad 0x3fdec399d2468cc0
+                    .quad 0x3fdf128f5faf06ed
+                    .quad 0x3fdf6123fa7028ac
+                    .quad 0x3fdfaf588f78f31f
+                    .quad 0x3fdffd2e0857f498
+                    .quad 0x3fe02552a5a5d0ff
+                    .quad 0x3fe04bdf9da926d2
+                    .quad 0x3fe0723e5c1cdf40
+                    .quad 0x3fe0986f4f573521
+                    .quad 0x3fe0be72e4252a83
+                    .quad 0x3fe0e44985d1cc8c
+                    .quad 0x3fe109f39e2d4c97
+                    .quad 0x3fe12f719593efbc
+                    .quad 0x3fe154c3d2f4d5ea
+                    .quad 0x3fe179eabbd899a1
+                    .quad 0x3fe19ee6b467c96f
+                    .quad 0x3fe1c3b81f713c25
+                    .quad 0x3fe1e85f5e7040d0
+                    .quad 0x3fe20cdcd192ab6e
+                    .quad 0x3fe23130d7bebf43
+                    .quad 0x3fe2555bce98f7cb
+                    .quad 0x3fe2795e1289b11b
+                    .quad 0x3fe29d37fec2b08b
+                    .quad 0x3fe2c0e9ed448e8c
+                    .quad 0x3fe2e47436e40268
+                    .quad 0x3fe307d7334f10be
+                    .quad 0x3fe32b1339121d71
+                    .quad 0x3fe34e289d9ce1d3
+                    .quad 0x3fe37117b54747b6
+                    .quad 0x3fe393e0d3562a1a
+                    .quad 0x3fe3b68449fffc23
+                    .quad 0x3fe3d9026a7156fb
+                    .quad 0x3fe3fb5b84d16f42
+                    .quad 0x3fe41d8fe84672ae
+                    .quad 0x3fe43f9fe2f9ce67
+                    .quad 0x3fe4618bc21c5ec2
+                    .quad 0x3fe48353d1ea88df
+                    .quad 0x3fe4a4f85db03ebb
+                    .quad 0x3fe4c679afccee3a
+                    .quad 0x3fe4e7d811b75bb1
+                    .quad 0x3fe50913cc01686b
+                    .quad 0x3fe52a2d265bc5ab
+                    .quad 0x3fe54b2467999498
+                    .quad 0x3fe56bf9d5b3f399
+                    .quad 0x3fe58cadb5cd7989
+                    .quad 0x3fe5ad404c359f2d
+                    .quad 0x3fe5cdb1dc6c1765
+                    .quad 0x3fe5ee02a9241675
+                    .quad 0x3fe60e32f44788d9
+                    .quad 0x3fe62e42fefa39ef
+
+.align 16
+.L__log_F_inv:
+                    .quad 0x4000000000000000
+                    .quad 0x3fffc07f01fc07f0
+                    .quad 0x3fff81f81f81f820
+                    .quad 0x3fff44659e4a4271
+                    .quad 0x3fff07c1f07c1f08
+                    .quad 0x3ffecc07b301ecc0
+                    .quad 0x3ffe9131abf0b767
+                    .quad 0x3ffe573ac901e574
+                    .quad 0x3ffe1e1e1e1e1e1e
+                    .quad 0x3ffde5d6e3f8868a
+                    .quad 0x3ffdae6076b981db
+                    .quad 0x3ffd77b654b82c34
+                    .quad 0x3ffd41d41d41d41d
+                    .quad 0x3ffd0cb58f6ec074
+                    .quad 0x3ffcd85689039b0b
+                    .quad 0x3ffca4b3055ee191
+                    .quad 0x3ffc71c71c71c71c
+                    .quad 0x3ffc3f8f01c3f8f0
+                    .quad 0x3ffc0e070381c0e0
+                    .quad 0x3ffbdd2b899406f7
+                    .quad 0x3ffbacf914c1bad0
+                    .quad 0x3ffb7d6c3dda338b
+                    .quad 0x3ffb4e81b4e81b4f
+                    .quad 0x3ffb2036406c80d9
+                    .quad 0x3ffaf286bca1af28
+                    .quad 0x3ffac5701ac5701b
+                    .quad 0x3ffa98ef606a63be
+                    .quad 0x3ffa6d01a6d01a6d
+                    .quad 0x3ffa41a41a41a41a
+                    .quad 0x3ffa16d3f97a4b02
+                    .quad 0x3ff9ec8e951033d9
+                    .quad 0x3ff9c2d14ee4a102
+                    .quad 0x3ff999999999999a
+                    .quad 0x3ff970e4f80cb872
+                    .quad 0x3ff948b0fcd6e9e0
+                    .quad 0x3ff920fb49d0e229
+                    .quad 0x3ff8f9c18f9c18fa
+                    .quad 0x3ff8d3018d3018d3
+                    .quad 0x3ff8acb90f6bf3aa
+                    .quad 0x3ff886e5f0abb04a
+                    .quad 0x3ff8618618618618
+                    .quad 0x3ff83c977ab2bedd
+                    .quad 0x3ff8181818181818
+                    .quad 0x3ff7f405fd017f40
+                    .quad 0x3ff7d05f417d05f4
+                    .quad 0x3ff7ad2208e0ecc3
+                    .quad 0x3ff78a4c8178a4c8
+                    .quad 0x3ff767dce434a9b1
+                    .quad 0x3ff745d1745d1746
+                    .quad 0x3ff724287f46debc
+                    .quad 0x3ff702e05c0b8170
+                    .quad 0x3ff6e1f76b4337c7
+                    .quad 0x3ff6c16c16c16c17
+                    .quad 0x3ff6a13cd1537290
+                    .quad 0x3ff6816816816817
+                    .quad 0x3ff661ec6a5122f9
+                    .quad 0x3ff642c8590b2164
+                    .quad 0x3ff623fa77016240
+                    .quad 0x3ff6058160581606
+                    .quad 0x3ff5e75bb8d015e7
+                    .quad 0x3ff5c9882b931057
+                    .quad 0x3ff5ac056b015ac0
+                    .quad 0x3ff58ed2308158ed
+                    .quad 0x3ff571ed3c506b3a
+                    .quad 0x3ff5555555555555
+                    .quad 0x3ff5390948f40feb
+                    .quad 0x3ff51d07eae2f815
+                    .quad 0x3ff5015015015015
+                    .quad 0x3ff4e5e0a72f0539
+                    .quad 0x3ff4cab88725af6e
+                    .quad 0x3ff4afd6a052bf5b
+                    .quad 0x3ff49539e3b2d067
+                    .quad 0x3ff47ae147ae147b
+                    .quad 0x3ff460cbc7f5cf9a
+                    .quad 0x3ff446f86562d9fb
+                    .quad 0x3ff42d6625d51f87
+                    .quad 0x3ff4141414141414
+                    .quad 0x3ff3fb013fb013fb
+                    .quad 0x3ff3e22cbce4a902
+                    .quad 0x3ff3c995a47babe7
+                    .quad 0x3ff3b13b13b13b14
+                    .quad 0x3ff3991c2c187f63
+                    .quad 0x3ff3813813813814
+                    .quad 0x3ff3698df3de0748
+                    .quad 0x3ff3521cfb2b78c1
+                    .quad 0x3ff33ae45b57bcb2
+                    .quad 0x3ff323e34a2b10bf
+                    .quad 0x3ff30d190130d190
+                    .quad 0x3ff2f684bda12f68
+                    .quad 0x3ff2e025c04b8097
+                    .quad 0x3ff2c9fb4d812ca0
+                    .quad 0x3ff2b404ad012b40
+                    .quad 0x3ff29e4129e4129e
+                    .quad 0x3ff288b01288b013
+                    .quad 0x3ff27350b8812735
+                    .quad 0x3ff25e22708092f1
+                    .quad 0x3ff2492492492492
+                    .quad 0x3ff23456789abcdf
+                    .quad 0x3ff21fb78121fb78
+                    .quad 0x3ff20b470c67c0d9
+                    .quad 0x3ff1f7047dc11f70
+                    .quad 0x3ff1e2ef3b3fb874
+                    .quad 0x3ff1cf06ada2811d
+                    .quad 0x3ff1bb4a4046ed29
+                    .quad 0x3ff1a7b9611a7b96
+                    .quad 0x3ff19453808ca29c
+                    .quad 0x3ff1811811811812
+                    .quad 0x3ff16e0689427379
+                    .quad 0x3ff15b1e5f75270d
+                    .quad 0x3ff1485f0e0acd3b
+                    .quad 0x3ff135c81135c811
+                    .quad 0x3ff12358e75d3033
+                    .quad 0x3ff1111111111111
+                    .quad 0x3ff0fef010fef011
+                    .quad 0x3ff0ecf56be69c90
+                    .quad 0x3ff0db20a88f4696
+                    .quad 0x3ff0c9714fbcda3b
+                    .quad 0x3ff0b7e6ec259dc8
+                    .quad 0x3ff0a6810a6810a7
+                    .quad 0x3ff0953f39010954
+                    .quad 0x3ff0842108421084
+                    .quad 0x3ff073260a47f7c6
+                    .quad 0x3ff0624dd2f1a9fc
+                    .quad 0x3ff05197f7d73404
+                    .quad 0x3ff0410410410410
+                    .quad 0x3ff03091b51f5e1a
+                    .quad 0x3ff0204081020408
+                    .quad 0x3ff0101010101010
+                    .quad 0x3ff0000000000000
+
+#---------------------
+# exp data
+#---------------------
+
+.align 16
+
+.L__real_zero:                  .quad 0x0000000000000000
+                                .quad 0
+
+.L__real_p4096:                 .quad 0x40b0000000000000
+                                .quad 0
+.L__real_m4768:                 .quad 0x0c0b2a00000000000
+                                .quad 0
+
+.L__real_32_by_log2:            .quad 0x40471547652b82fe # 32/ln(2)
+                                .quad 0
+.L__real_log2_by_32:            .quad 0x3f962e42fefa39ef # log2_by_32
+                                .quad 0
+
+.L__real_1_by_24:               .quad 0x3fa5555555555555 # 1/24
+                                .quad 0
+.L__real_1_by_6:                .quad 0x3fc5555555555555 # 1/6
+                                .quad 0
+.L__real_1_by_2:                .quad 0x3fe0000000000000 # 1/2
+                                .quad 0
+.L__real_1_by_1:                .quad 0x3ff0000000000000 # 1
+                                .quad 0
+
+.align 16
+
+.L__two_to_jby32_table:
+    .quad 0x3ff0000000000000
+    .quad 0x3ff059b0d3158574
+    .quad 0x3ff0b5586cf9890f
+    .quad 0x3ff11301d0125b51
+    .quad 0x3ff172b83c7d517b
+    .quad 0x3ff1d4873168b9aa
+    .quad 0x3ff2387a6e756238
+    .quad 0x3ff29e9df51fdee1
+    .quad 0x3ff306fe0a31b715
+    .quad 0x3ff371a7373aa9cb
+    .quad 0x3ff3dea64c123422
+    .quad 0x3ff44e086061892d
+    .quad 0x3ff4bfdad5362a27
+    .quad 0x3ff5342b569d4f82
+    .quad 0x3ff5ab07dd485429
+    .quad 0x3ff6247eb03a5585
+    .quad 0x3ff6a09e667f3bcd
+    .quad 0x3ff71f75e8ec5f74
+    .quad 0x3ff7a11473eb0187
+    .quad 0x3ff82589994cce13
+    .quad 0x3ff8ace5422aa0db
+    .quad 0x3ff93737b0cdc5e5
+    .quad 0x3ff9c49182a3f090
+    .quad 0x3ffa5503b23e255d
+    .quad 0x3ffae89f995ad3ad
+    .quad 0x3ffb7f76f2fb5e47
+    .quad 0x3ffc199bdd85529c
+    .quad 0x3ffcb720dcef9069
+    .quad 0x3ffd5818dcfba487
+    .quad 0x3ffdfc97337b9b5f
+    .quad 0x3ffea4afa2a490da
+    .quad 0x3fff50765b6e4540
+
+
diff --git a/src/gas/remainder.S b/src/gas/remainder.S
new file mode 100644
index 0000000..173da80
--- /dev/null
+++ b/src/gas/remainder.S
@@ -0,0 +1,256 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+# remainder.S
+#
+# An implementation of the fabs libm function.
+#
+# Prototype:
+#
+#     double remainder(double x,double y);
+#
+
+#
+#   Algorithm:
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(remainder)
+#define fname_special _remainder_special
+
+
+# local variable storage offsets
+.equ    temp_x, 0x0
+.equ    temp_y, 0x10
+.equ    stack_size,  0x28
+
+.equ    stack_size,  0x80
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+    movd %xmm0,%r8
+    movd %xmm1,%r9
+    movsd %xmm0,%xmm2
+    movsd %xmm1,%xmm3
+    movsd %xmm0,%xmm4
+    movsd %xmm1,%xmm5
+    mov .L__exp_mask_64(%rip), %r10
+    and %r10,%r8
+    and %r10,%r9
+    xor %r10,%r10
+    ror $52, %r8
+    ror $52, %r9
+    cmp $0,%r8
+    jz  .L__LargeExpDiffComputation
+    cmp $0,%r9
+    jz  .L__LargeExpDiffComputation
+    sub %r9,%r8 #
+    cmp $52,%r8
+    jge .L__LargeExpDiffComputation
+    pand .L__Nan_64(%rip),%xmm4
+    pand .L__Nan_64(%rip),%xmm5
+    comisd %xmm5,%xmm4
+    jp  .L__InputIsNaN # if either of xmm1 or xmm0 is a NaN then 
+                       # parity flag is set
+    jz  .L__Input_Is_Equal
+    jbe .L__ReturnImmediate
+    cmp $0x7FF,%r8
+    jz  .L__Dividend_Is_Infinity
+
+    #calculation without using the x87 FPU
+.L__DirectComputation:
+    movapd %xmm4,%xmm2
+    movapd %xmm5,%xmm3
+    divsd %xmm3,%xmm2
+    cvttsd2siq %xmm2,%r8
+    mov   %r8,%r10
+    and   $0X01,%r10
+    cvtsi2sdq %r8,%xmm2
+
+    #multiplication in QUAD Precision
+    #Since the below commented multiplication resulted in an error
+    #we had to implement a quad precision multiplication
+    #logic behind Quad Precision Multiplication
+    #x = hx + tx   by setting x's last 27 bits to null
+    #y = hy + ty   similar to x
+    movapd .L__27bit_andingmask_64(%rip),%xmm4 
+    movapd %xmm5,%xmm1 # x
+    movapd %xmm2,%xmm6 # y
+    movapd %xmm2,%xmm7 # z = xmm7
+    mulpd  %xmm5,%xmm7 # z = x*y
+    andpd  %xmm4,%xmm1
+    andpd  %xmm4,%xmm2
+    subsd  %xmm1,%xmm5 # xmm1 = hx   xmm5 = tx
+    subsd  %xmm2,%xmm6 # xmm2 = hy   xmm6 = ty
+
+    movapd %xmm1,%xmm4 # copy hx
+    mulsd  %xmm2,%xmm4 # xmm4 = hx*hy
+    subsd  %xmm7,%xmm4 # xmm4 = (hx*hy - z)
+    mulsd  %xmm6,%xmm1 # xmm1 = hx * ty
+    addsd  %xmm1,%xmm4 # xmm4 = ((hx * hy - *z) + hx * ty)
+    mulsd  %xmm5,%xmm2 # xmm2 = tx * hy
+    addsd  %xmm2,%xmm4 # xmm4 = (((hx * hy - *z) + hx * ty) + tx * hy)
+    mulsd  %xmm5,%xmm6 # xmm6 = tx * ty
+    addsd  %xmm4,%xmm6 # xmm6 = (((hx * hy - *z) + hx * ty) + tx * hy) + tx * ty;
+    #xmm6 and xmm7 contain the quad precision result
+    #v = dx - c;
+    movapd %xmm0,%xmm1 # copy the input number
+    pand   .L__Nan_64(%rip),%xmm1
+    movapd %xmm1,%xmm2 # xmm2 = dx = xmm1
+    subsd  %xmm7,%xmm1 # v = dx - c
+    subsd  %xmm1,%xmm2 # (dx - v)
+    subsd  %xmm7,%xmm2 # ((dx - v) - c)
+    subsd  %xmm6,%xmm2 # (((dx - v) - c) - cc)
+    addsd  %xmm1,%xmm2 # xmm2 = dx = v + (((dx - v) - c) - cc) 
+                       # xmm3 = w
+    movapd %xmm2,%xmm4 
+    movapd %xmm3,%xmm5 
+    addsd  %xmm4,%xmm4 # xmm4 = dx + dx
+    comisd %xmm4,%xmm3 # if (dx + dx > w)
+    jb .L__Substractw
+    mulpd  .L__ZeroPointFive(%rip),%xmm5 # xmm5 = 0.5 * w
+    comisd %xmm2,%xmm5 # if (dx > 0.5 * w)
+    jb .L__Substractw
+    cmp $0x01,%r10     # If the quotient is an odd number
+    jnz .L__Finish
+    comisd %xmm4,%xmm3 #if (todd && (dx + dx == w)) then subtract w
+    jz  .L__Substractw
+    comisd %xmm0,%xmm5 #if (todd && (dx == 0.5 * w)) then subtract w
+    jnz  .L__Finish
+
+.L__Substractw:
+    subsd %xmm3,%xmm2  # dx -= w
+
+# The following code checks the sign of the input number and then calculate the return Value
+#  return x < 0.0? -dx : dx;
+.L__Finish:
+    comisd .L__Zero_64(%rip), %xmm0 
+    ja  .L__Not_Negative_Number1
+
+.L__Negative_Number1:
+    movapd .L__Zero_64(%rip),%xmm0
+    subsd  %xmm2,%xmm0
+    ret 
+.L__Not_Negative_Number1:
+    movapd %xmm2,%xmm0 
+    ret 
+
+
+    #calculation using the x87 FPU
+    #For numbers whose exponent of either of the divisor,
+    #or dividends are 0. Or for numbers whose exponential 
+    #diff is grater than 52
+.align 16
+.L__LargeExpDiffComputation:
+    sub $stack_size, %rsp
+    movsd %xmm0, temp_x(%rsp)
+    movsd %xmm1, temp_y(%rsp)
+    ffree %st(0)
+    ffree %st(1)
+    fldl  temp_y(%rsp)
+    fldl  temp_x(%rsp)
+    fnclex
+.align 16
+.L__repeat:    
+    fprem1 #Calculate remainder by dividing st(0) with st(1)
+           #fprem operation sets x87 condition codes, 
+           #it will set the C2 code to 1 if a partial remainder is calculated
+    fnstsw %ax 
+    and $0x0400,%ax # Stores Floating-Point Store Status Word into the accumulator 
+                    # we need to check only the C2 bit of the Condition codes
+    cmp $0x0400,%ax # Checks whether the bit 10(C2) is set or not 
+                    # IF its set then a partial remainder was calculated
+    jz .L__repeat 
+    #store the result from the FPU stack to memory
+    fstpl   temp_x(%rsp)
+    fstpl   temp_y(%rsp)
+    movsd   temp_x(%rsp), %xmm0 
+    add $stack_size, %rsp
+    ret 
+
+    #IF both the inputs are equal
+.L__Input_Is_Equal:
+    cmp $0x7FF,%r8
+    jz .L__Dividend_Is_Infinity
+    cmp $0x7FF,%r9
+    jz .L__InputIsNaN
+    movsd %xmm0,%xmm1
+    pand .L__sign_mask_64(%rip),%xmm1
+    movsd .L__Zero_64(%rip),%xmm0
+    por  %xmm1,%xmm0
+    ret
+
+.L__InputIsNaN:
+    por .L__QNaN_mask_64(%rip),%xmm0
+    por .L__exp_mask_64(%rip),%xmm0
+.L__Dividend_Is_Infinity:
+    ret
+
+#Case when x < y
+.L__ReturnImmediate:
+    movapd %xmm5,%xmm7 
+    mulpd  .L__ZeroPointFive(%rip),%xmm5 # 
+    comisd %xmm4,%xmm5
+    jae  .L__FoundResult1
+    subsd %xmm7,%xmm4
+    comisd  .L__Zero_64(%rip),%xmm0
+    ja  .L__Not_Negative_Number
+.L__Negative_Number:
+    movapd .L__Zero_64(%rip),%xmm0
+    subsd  %xmm4,%xmm0
+    ret 
+
+.L__Not_Negative_Number:
+    movapd %xmm4,%xmm0
+    ret
+.align 16    
+.L__FoundResult1:
+    ret
+    
+
+
+.align 32    
+.L__sign_mask_64:          .quad 0x8000000000000000
+                           .quad 0x0
+.L__exp_mask_64:           .quad 0x7FF0000000000000
+                           .quad 0x0
+.L__27bit_andingmask_64:   .quad 0xfffffffff8000000
+                           .quad 0
+.L__2p52_mask_64:          .quad 0x4330000000000000 
+                           .quad 0
+.L__Zero_64:               .quad 0x0 
+                           .quad 0
+.L__QNaN_mask_64:          .quad 0x0008000000000000 
+                           .quad 0
+.L__Nan_64:                .quad 0x7FFFFFFFFFFFFFFF
+                           .quad 0
+.L__ZeroPointFive:         .quad 0X3FE0000000000000
+                           .quad 0
+
diff --git a/src/gas/remainderf.S b/src/gas/remainderf.S
new file mode 100644
index 0000000..d196d11
--- /dev/null
+++ b/src/gas/remainderf.S
@@ -0,0 +1,221 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+# remainderf.S
+#
+# An implementation of the fabs libm function.
+#
+# Prototype:
+#
+#     float remainderf(float x,float y);
+#
+
+#
+#   Algorithm:
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(remainderf)
+#define fname_special _remainderf_special
+
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+    mov .L__exp_mask_64(%rip), %rdi
+    movapd .L__sign_mask_64(%rip),%xmm6
+    cvtss2sd %xmm0,%xmm2 # double x
+    cvtss2sd %xmm1,%xmm3 # double y
+    pand %xmm6,%xmm2
+    pand %xmm6,%xmm3
+    movd %xmm2,%rax
+    movd %xmm3,%r8
+    mov %rax,%r11
+    mov %r8,%r9
+    movsd %xmm2,%xmm4
+    #take the exponents of both x and y
+    and %rdi,%rax
+    and %rdi,%r8
+    ror $52, %rax
+    ror $52, %r8
+    #ifeither of the exponents is infinity 
+    cmp $0X7FF,%rax 
+    jz  .L__InputIsNaN 
+    cmp $0X7FF,%r8 
+    jz  .L__InputIsNaNOrInf
+
+    cmp $0,%r8
+    jz  .L__Divisor_Is_Zero
+
+    cmp %r9, %r11
+    jz  .L__Input_Is_Equal
+    jb  .L__ReturnImmediate
+
+    xor %rcx,%rcx
+    mov $24,%rdx
+    movsd .L__One_64(%rip),%xmm7 # xmm7 = scale
+    cmp %rax,%r8 
+    jae .L__y_is_greater
+    #xmm3 = dy
+    sub %r8,%rax
+    div %dl       # al = ntimes
+    mov %al,%cl   # cl = ntimes
+    and $0xFF,%ax # set everything t o zero except al
+    mul %dl       # ax = dl * al = 24* ntimes
+    add $1023, %rax
+    shl $52,%rax
+    movd %rax,%xmm7 # xmm7 = scale
+.L__y_is_greater:
+    mulsd %xmm3,%xmm7 # xmm7 = scale * dy
+    movsd .L__2pminus24_decimal(%rip),%xmm6
+
+.align 16
+.L__Start_Loop:
+    dec %cl
+    js .L__End_Loop
+    divsd %xmm7,%xmm4     # xmm7 = (dx / w)
+    cvttsd2siq %xmm4,%rax 
+    cvtsi2sdq %rax,%xmm4  # xmm4 = t = (double)((int)(dx / w))
+    mulsd  %xmm7,%xmm4    # xmm4 = w*t
+    mulsd %xmm6,%xmm7     # w*= scale 
+    subsd  %xmm4,%xmm2    # xmm2 = dx -= w*t  
+    movsd %xmm2,%xmm4     # xmm4 = dx
+    jmp .L__Start_Loop
+.L__End_Loop:    
+    divsd %xmm7,%xmm4     # xmm7 = (dx / w)
+    cvttsd2siq %xmm4,%rax 
+    cvtsi2sdq %rax,%xmm4  # xmm4 = t = (double)((int)(dx / w))
+    and $0x01,%rax        # todd = todd = ((int)(dx / w)) & 1 
+    mulsd  %xmm7,%xmm4    # xmm4 = w*t
+    subsd  %xmm4,%xmm2    # xmm2 = dx -= w*t  
+    movsd  %xmm7,%xmm6    # store w
+    mulsd .L__Zero_Point_Five64(%rip),%xmm7 #xmm7 = 0.5*w
+    
+    cmp $0x01,%rax
+    jnz .L__todd_is_even
+    comisd %xmm2,%xmm7
+    je .L__Subtract_w
+
+.L__todd_is_even: 
+    comisd %xmm2,%xmm7
+    jnb .L__Dont_Subtract_w
+    
+.L__Subtract_w:    
+    subsd %xmm6,%xmm2
+    
+.L__Dont_Subtract_w:
+    comiss .L__Zero_64(%rip),%xmm0 
+    jb .L__Negative
+    cvtsd2ss %xmm2,%xmm0 
+    ret
+.L__Negative:
+    movsd .L__MinusZero_64(%rip),%xmm0
+    subsd %xmm2,%xmm0
+    cvtsd2ss %xmm0,%xmm0 
+    ret
+
+.align 16
+.L__Input_Is_Equal:
+    cmp $0x7FF,%rax
+    jz .L__Dividend_Is_Infinity
+    cmp $0x7FF,%r8
+    jz .L__InputIsNaNOrInf
+    movsd %xmm0,%xmm1
+    pand .L__sign_bit_32(%rip),%xmm1
+    movss .L__Zero_64(%rip),%xmm0
+    por  %xmm1,%xmm0
+    ret
+
+.L__InputIsNaNOrInf:
+    comiss %xmm0,%xmm1
+    jp .L__InputIsNaN
+    ret
+.L__Divisor_Is_Zero:
+.L__InputIsNaN:
+    por .L__exp_mask_32(%rip),%xmm0
+.L__Dividend_Is_Infinity:
+    por .L__QNaN_mask_32(%rip),%xmm0
+    ret
+
+#Case when x < y
+    #xmm2 = dx
+.L__ReturnImmediate:
+    movsd %xmm3,%xmm5
+    mulsd .L__Zero_Point_Five64(%rip), %xmm3 # xmm3 = 0.5*dy
+    comisd %xmm3,%xmm2 # if (dx > 0.5*dy)
+    jna .L__Finish_Immediate # xmm2 <= xmm3
+    subsd %xmm5,%xmm2 #dx -= dy
+    
+.L__Finish_Immediate:
+    comiss .L__Zero_64(%rip),%xmm0
+    #xmm0 contains the input and is the result
+    jz .L__Zero
+    ja .L__Positive
+
+    movsd .L__Zero_64(%rip),%xmm0
+    subsd %xmm2,%xmm0
+    cvtsd2ss %xmm0,%xmm0
+    ret
+
+.L__Zero:
+    ret
+        
+.L__Positive:
+    cvtsd2ss %xmm2,%xmm0
+    ret
+    
+
+
+.align 32    
+.L__sign_bit_32:           .quad 0x8000000080000000
+                           .quad 0x0
+.L__exp_mask_64:           .quad 0x7FF0000000000000
+                           .quad 0x0
+.L__exp_mask_32:           .quad 0x000000007F800000
+                           .quad 0x0
+.L__27bit_andingmask_64:   .quad 0xfffffffff8000000
+                           .quad 0
+.L__2p52_mask_64:          .quad 0x4330000000000000 
+                           .quad 0
+.L__One_64:                .quad 0x3FF0000000000000 
+                           .quad 0
+.L__Zero_64:               .quad 0x0 
+                           .quad 0
+.L__MinusZero_64:          .quad 0x8000000000000000 
+                           .quad 0
+.L__QNaN_mask_32:          .quad 0x0000000000400000
+                           .quad 0
+.L__sign_mask_64:          .quad 0x7FFFFFFFFFFFFFFF
+                           .quad 0
+.L__2pminus24_decimal:     .quad 0x3E70000000000000
+                           .quad 0
+.L__Zero_Point_Five64:     .quad 0x3FE0000000000000
+                           .quad 0
+
diff --git a/src/gas/round.S b/src/gas/round.S
new file mode 100644
index 0000000..c1ac20a
--- /dev/null
+++ b/src/gas/round.S
@@ -0,0 +1,151 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+# round.S
+#
+# An implementation of the round libm function.
+#
+# Prototype:
+#
+#     double round(double x);
+#
+
+#
+#   Algorithm: First get the exponent of the input 
+#              double precision number. 
+#              IF exponent is greater than 51 then return the 
+#              input as is. 
+#              IF exponent is less than 0 then force an overflow
+#              by adding a huge number and subtracting with the 
+#              same number. 
+#              IF exponent is greater than 0 then add 0.5 and 
+#              and shift the mantissa bits based on the exponent
+#              value to discard the fractional component. 
+#              
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(round)
+#define fname_special _round_special
+
+
+# local variable storage offsets
+
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+#in sse5 there is a roundss,roundsd instruction
+fname:
+    movsd .L__2p52_plus_one(%rip),%xmm4
+    movsd .L__sign_mask_64(%rip),%xmm5
+    mov $52,%r10
+    #take 3 copies of the input xmm0
+    movsd %xmm0,%xmm1
+    movsd %xmm0,%xmm2
+    movsd %xmm0,%xmm3
+    #get the Most signifacnt half word of the input number in r9
+    pand .L__exp_mask_64(%rip), %xmm1
+    pextrw $3,%xmm1,%r9
+    cmp $0X7FF0,%r9
+    #Check for infinity inputs
+    jz .L__is_infinity
+    movsd .L__sign_mask_64(%rip), %xmm1
+    pandn %xmm2,%xmm1 # xmm1 now stores the sign of the input number 
+    #On shifting r9 and subtracting with 0x3FF 
+    #r9 stores the exponent.
+    shr   $0X4,%r9
+    sub $0x3FF,%r9
+    cmp $0x00, %r9
+    jl .L__number_less_than_zero
+
+    #IF exponent is greater than 0
+.L__number_greater_than_zero:
+    cmp $51,%r9
+    jg .L__is_greater_than_2p52
+    
+    #IF exponent is greater than 0 and less than 2^52
+    pand .L__sign_mask_64(%rip),%xmm0
+    #add with 0.5
+    addsd .L__zero_point_5(%rip),%xmm0
+    movsd %xmm0,%xmm5
+
+    pand  .L__exp_mask_64(%rip),%xmm5
+    pand  .L__mantissa_mask_64(%rip),%xmm0
+    #r10 = r9(input exponent) - r10(52=mantissa length) 
+    sub %r9,%r10
+    movd %r10, %xmm2
+    #do right and left shift by (input exp - mantissa length)
+    psrlq %xmm2,%xmm0
+    psllq %xmm2,%xmm0
+    #OR the input exponent with the input sign
+    por  %xmm1,%xmm5
+    #finally OR with the matissa
+    por %xmm5,%xmm0
+    ret
+
+    #IF exponent is less than 0
+.L__number_less_than_zero:
+    pand %xmm5,%xmm3 # xmm3 =abs(input) 
+    addsd %xmm4,%xmm3# add (2^52 + 1)
+    subsd %xmm4,%xmm3# sub (2^52 + 1)
+    por %xmm1, %xmm3 # OR with the sign of the input number 
+    movsd %xmm3,%xmm0 
+    ret
+
+    #IF the input is infinity
+.L__is_infinity:
+    comisd %xmm4,%xmm0
+    jnp .L__is_zero #parity flag is raised 
+                    #IF one of theinputs is a Nan
+.L__is_nan :
+    por .L__qnan_mask_64(%rip),%xmm0 # set the QNan Bit
+.L__is_zero :
+.L__is_greater_than_2p52:    
+    ret
+
+.align 16
+.L__sign_mask_64:          .quad 0x7FFFFFFFFFFFFFFF
+                           .quad 0
+
+.L__qnan_mask_64:          .quad 0x0008000000000000
+                           .quad 0
+.L__exp_mask_64:           .quad 0x7FF0000000000000
+                           .quad 0
+.L__mantissa_mask_64:      .quad 0x000FFFFFFFFFFFFF
+                           .quad 0
+.L__zero:                  .quad 0x0000000000000000
+                           .quad 0
+.L__2p52_plus_one:         .quad 0x4330000000000001  # = 4503599627370497.0
+                           .quad 0
+.L__zero_point_5:          .quad 0x3FE0000000000001  # = 00.5
+                           .quad 0
+
+
+
diff --git a/src/gas/sin.S b/src/gas/sin.S
new file mode 100644
index 0000000..378e103
--- /dev/null
+++ b/src/gas/sin.S
@@ -0,0 +1,481 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#
+# An implementation of the sin function.
+#
+# Prototype:
+#
+#     double sin(double x);
+#
+#   Computes sin(x).
+#   It will provide proper C99 return values,
+#   but may not raise floating point status bits properly.
+#   Based on the NAG C implementation.
+#
+#
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.data
+.align 32
+.L__real_3fe0000000000000: .quad 0x03fe0000000000000  # 0.5
+                  .quad 0                             # for alignment
+.L__real_3ff0000000000000: .quad 0x03ff0000000000000  # 1.0
+                  .quad 0               
+.L__real_3fc5555555555555: .quad 0x03fc5555555555555  # 0.166666666666
+                  .quad 0
+.L__real_3fe45f306dc9c883: .quad 0x03fe45f306dc9c883  # twobypi
+                  .quad 0
+.L__real_411E848000000000: .quad 0x415312d000000000   # 5e6 0x0411E848000000000  # 5e5
+                  .quad 0
+.L__real_7fffffffffffffff: .quad 0x07fffffffffffffff  # Sign bit zero
+                  .quad 0
+.L__real_3ff921fb54400000: .quad 0x03ff921fb54400000  # piby2_1
+                  .quad 0
+.L__real_3dd0b4611a626331: .quad 0x03dd0b4611a626331  # piby2_1tail
+                  .quad 0
+.L__real_3dd0b4611a600000: .quad 0x03dd0b4611a600000  # piby2_2
+                  .quad 0
+.L__real_3ba3198a2e037073: .quad 0x03ba3198a2e037073  # piby2_2tail
+                  .quad 0               
+                  
+.align 32
+.Lcosarray:
+   .quad   0x03fa5555555555555                        # 0.0416667         c1
+   .quad   0
+   .quad   0x0bf56c16c16c16967                        # -0.00138889       c2
+   .quad   0
+   .quad   0x03EFA01A019F4EC91                        # 2.48016e-005      c3
+   .quad   0
+   .quad   0x0bE927E4FA17F667B                        # -2.75573e-007     c4
+   .quad   0
+   .quad   0x03E21EEB690382EEC                        # 2.08761e-009      c5
+   .quad   0
+   .quad   0x0bDA907DB47258AA7                        # -1.13826e-011     c6
+   .quad   0
+
+.align 32
+.Lsinarray:
+   .quad   0x0bfc5555555555555                        # -0.166667         s1
+   .quad   0
+   .quad   0x03f81111111110bb3                        # 0.00833333        s2
+   .quad   0
+   .quad   0x0bf2a01a019e83e5c                        # -0.000198413      s3
+   .quad   0
+   .quad   0x03ec71de3796cde01                        # 2.75573e-006      s4
+   .quad   0
+   .quad   0x0be5ae600b42fdfa7                        # -2.50511e-008     s5
+   .quad   0
+   .quad   0x03de5e0b2f9a43bb8                        # 1.59181e-010      s6
+   .quad   0
+
+.text
+.align 32
+.p2align 4,,15
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(sin)
+#define fname_special _sin_special@PLT
+
+# define local variable storage offsets
+.equ   p_temp,     0x30                               # temporary for get/put bits operation
+.equ   p_temp1,    0x40                               # temporary for get/put bits operation
+.equ   r,          0x50                               # pointer to r for amd_remainder_piby2
+.equ   rr,         0x60                               # pointer to rr for amd_remainder_piby2
+.equ   region,     0x70                               # pointer to region for amd_remainder_piby2
+.equ   stack_size, 0x98
+
+.globl fname
+.type  fname,@function
+
+fname:
+   sub      $stack_size, %rsp
+   xorpd    %xmm2, %xmm2                              # zeroed out for later use
+
+# GET_BITS_DP64(x, ux);
+# get the input value to an integer register.
+   movsd    %xmm0, p_temp(%rsp)
+   mov      p_temp(%rsp), %rdx                        # rdx is ux
+
+##  if NaN or inf
+   mov      $0x07ff0000000000000, %rax
+   mov      %rax, %r10
+   and      %rdx, %r10
+   cmp      %rax, %r10
+   jz       .Lsin_naninf
+
+#  ax = (ux & ~SIGNBIT_DP64);
+   mov      $0x07fffffffffffffff, %r10
+   and      %rdx, %r10                                # r10 is ax
+   mov      $1, %r8d                                  # for determining region later on
+
+##  if (ax <= 0x3fe921fb54442d18) /* abs(x) <= pi/4 */
+   mov      $0x03fe921fb54442d18, %rax
+   cmp      %rax, %r10
+   jg       .Lsin_reduce
+
+##      if (ax < 0x3f20000000000000) /* abs(x) < 2.0^(-13) */
+   mov      $0x03f20000000000000, %rax
+   cmp      %rax, %r10
+   jge      .Lsin_small
+
+##          if (ax < 0x3e40000000000000) /* abs(x) < 2.0^(-27) */
+   mov      $0x03e40000000000000, %rax
+   cmp      %rax, %r10
+   jge      .Lsin_smaller
+
+#                  sin = 1.0;
+   jmp      .Lsin_cleanup         
+   
+.align 32
+.Lsin_smaller:
+#              sin = x - x^3 * 0.1666666666666666666;
+   movsd    %xmm0, %xmm2
+   movsd    .L__real_3fc5555555555555(%rip), %xmm4    # 0.1666666666666666666
+   mulsd    %xmm2, %xmm2                              # x^2
+   mulsd    %xmm0, %xmm2                              # x^3
+   mulsd    %xmm4, %xmm2                              # x^3 * 0.1666666666666666666
+   subsd    %xmm2, %xmm0                              # x - x^3 * 0.1666666666666666666
+   jmp      .Lsin_cleanup           
+
+.align 32
+.Lsin_small:
+#          sin = sin_piby4(x, 0.0);
+   movsd    .L__real_3fe0000000000000(%rip), %xmm5   # .5
+
+.Lsin_piby4_noreduce:
+   movsd    %xmm0, %xmm2
+   mulsd    %xmm0, %xmm2                              # x2
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# region 0 or 2    - do a sin calculation
+#  zs = (s2 + x2 * (s3 + x2 * (s4 + x2 * (s5 + x2 * s6))));
+   movsd    .Lsinarray+0x50(%rip), %xmm3              # s6
+   mulsd    %xmm2, %xmm3                              # x2s6
+   movsd    .Lsinarray+0x20(%rip), %xmm5              # s3
+   movsd    %xmm2, %xmm1                              # move for x4
+   mulsd    %xmm2, %xmm1                              # x4
+   mulsd    %xmm2, %xmm5                              # x2s3
+   movsd    %xmm0, %xmm4                              # move for x3
+   addsd    .Lsinarray+0x40(%rip), %xmm3              # s5+x2s6
+   mulsd    %xmm2, %xmm1                              # x6
+   mulsd    %xmm2, %xmm3                              # x2(s5+x2s6)
+   mulsd    %xmm2, %xmm4                              # x3
+   addsd    .Lsinarray+0x10(%rip), %xmm5              # s2+x2s3
+   mulsd    %xmm2, %xmm5                              # x2(s2+x2s3)
+   addsd    .Lsinarray+0x30(%rip), %xmm3              # s4 + x2(s5+x2s6)
+   mulsd    %xmm1, %xmm3                              # x6(s4 + x2(s5+x2s6))
+   addsd    .Lsinarray(%rip), %xmm5                   # s1+x2(s2+x2s3)
+   addsd    %xmm5, %xmm3                              # zs
+   mulsd    %xmm3, %xmm4                              # *x3
+   addsd    %xmm4, %xmm0                              # +x
+   jmp      .Lsin_cleanup
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lsin_reduce:
+#  xneg = (ax != ux);
+   cmp      %r10, %rdx
+   mov      $0, %r11d
+
+##  if (xneg) x = -x;
+   jz       .Lpositive
+   mov      $1, %r11d
+   subsd    %xmm0, %xmm2
+   movsd    %xmm2, %xmm0
+
+.align 16
+.Lpositive:
+##  if (x < 5.0e5)
+   cmp      .L__real_411E848000000000(%rip), %r10
+   jae      .Lsin_reduce_precise
+
+# reduce  the argument to be in a range from -pi/4 to +pi/4
+# by subtracting multiples of pi/2
+   movsd    %xmm0, %xmm2
+   movsd    .L__real_3fe45f306dc9c883(%rip), %xmm3    # twobypi
+   movsd    %xmm0, %xmm4
+   movsd    .L__real_3fe0000000000000(%rip), %xmm5    # .5
+   mulsd    %xmm3, %xmm2
+
+#/* How many pi/2 is x a multiple of? */
+#      xexp  = ax >> EXPSHIFTBITS_DP64;
+   mov      %r10, %r9
+   shr      $52, %r9                                  # >>EXPSHIFTBITS_DP64
+
+#        npi2  = (int)(x * twobypi + 0.5);
+   addsd    %xmm5, %xmm2                              # npi2
+
+   movsd    .L__real_3ff921fb54400000(%rip), %xmm3    # piby2_1
+   cvttpd2dq   %xmm2, %xmm0                           # convert to integer
+   movsd    .L__real_3dd0b4611a626331(%rip), %xmm1    # piby2_1tail
+   cvtdq2pd   %xmm0, %xmm2                            # and back to float.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+#      rhead  = x - npi2 * piby2_1;
+   mulsd    %xmm2, %xmm3
+   subsd    %xmm3, %xmm4                              # rhead
+
+#      rtail  = npi2 * piby2_1tail;
+   mulsd    %xmm2, %xmm1
+   movd     %xmm0, %eax
+
+#      GET_BITS_DP64(rhead-rtail, uy);               
+   movsd    %xmm4, %xmm0
+   subsd    %xmm1, %xmm0
+
+   movsd    .L__real_3dd0b4611a600000(%rip), %xmm3    # piby2_2
+   movsd    %xmm0,p_temp(%rsp)
+   movsd    .L__real_3ba3198a2e037073(%rip), %xmm5    # piby2_2tail
+   mov      p_temp(%rsp), %rcx                        # rcx is rhead-rtail
+
+#   xmm0=r, xmm4=rhead, xmm1=rtail, xmm2=npi2, xmm3=temp for calc, xmm5= temp for calc
+#      expdiff = xexp - ((uy & EXPBITS_DP64) >> EXPSHIFTBITS_DP64);
+   shl      $1, %rcx                                  # strip any sign bit
+   shr      $53, %rcx                                 # >> EXPSHIFTBITS_DP64 +1
+   sub      %rcx, %r9                                 # expdiff
+
+##      if (expdiff > 15)
+   cmp      $15, %r9
+   jle      .Lexplediff15
+
+#          /* The remainder is pretty small compared with x, which
+#             implies that x is a near multiple of pi/2
+#             (x matches the multiple to at least 15 bits) */
+
+#          t  = rhead;
+   movsd    %xmm4, %xmm1
+
+#          rtail  = npi2 * piby2_2;
+   mulsd    %xmm2, %xmm3
+
+#          rhead  = t - rtail;
+   mulsd    %xmm2, %xmm5                              # npi2 * piby2_2tail
+   subsd    %xmm3, %xmm4                              # rhead
+
+#          rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+   subsd    %xmm4, %xmm1                              # t - rhead
+   subsd    %xmm3, %xmm1                              # -rtail
+   subsd    %xmm1, %xmm5                              # rtail
+
+#      r = rhead - rtail;
+   movsd    %xmm4, %xmm0
+
+#HARSHA
+#xmm1=rtail
+   movsd    %xmm5, %xmm1
+   subsd    %xmm5, %xmm0
+
+#   xmm0=r, xmm4=rhead, xmm1=rtail
+.Lexplediff15:
+#      region = npi2 & 3;
+
+   subsd    %xmm0, %xmm4                              # rhead-r
+   subsd    %xmm1, %xmm4                              # rr = (rhead-r) - rtail
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+## if the input was close to a pi/2 multiple
+# The original NAG code missed this trick.  If the input is very close to n*pi/2 after
+# reduction,
+# then the sin is ~ 1.0 , to within 53 bits, when r is < 2^-27.  We already
+# have x at this point, so we can skip the sin polynomials.
+
+   cmp      $0x03f2, %rcx                             # if r  small.
+   jge      .Lsin_piby4                               # use taylor series if not
+   cmp      $0x03de, %rcx                             # if r really small.
+   jle      .Lr_small                                 # then sin(r) = 0
+
+   movsd    %xmm0, %xmm2
+   mulsd    %xmm2, %xmm2                              # x^2
+
+##      if region is 0 or 2 do a sin calc.
+   and      %eax, %r8d
+   jnz      .Lcossmall
+
+# region 0 or 2 do a sin calculation
+# use simply polynomial
+#              x - x*x*x*0.166666666666666666;
+   movsd    .L__real_3fc5555555555555(%rip), %xmm3     
+   mulsd    %xmm0, %xmm3                              # * x
+   mulsd    %xmm2, %xmm3                              # * x^2
+   subsd    %xmm3, %xmm0                              # xs
+   jmp      .Ladjust_region
+
+.align 16
+.Lcossmall:
+# region 1 or 3 do a cos calculation
+# use simply polynomial
+#              1.0 - x*x*0.5;
+   movsd    .L__real_3ff0000000000000(%rip), %xmm0    # 1.0
+   mulsd    .L__real_3fe0000000000000(%rip), %xmm2    # 0.5 *x^2
+   subsd    %xmm2, %xmm0                              # xc
+   jmp      .Ladjust_region
+
+.align 16
+.Lr_small:
+##      if region is 1 or 3   do a cos calc.
+   and      %eax, %r8d
+   jz       .Ladjust_region
+
+# odd
+   movsd    .L__real_3ff0000000000000(%rip), %xmm0    # cos(r) is a 1
+   jmp      .Ladjust_region
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 32
+.Lsin_reduce_precise:
+#      // Reduce x into range [-pi/4,pi/4]
+#      __amd_remainder_piby2(x, &r, &rr, &region);
+
+   mov      %r11,p_temp(%rsp)
+   lea      region(%rsp), %rdx
+   lea      rr(%rsp), %rsi
+   lea      r(%rsp), %rdi
+   
+   call     __amd_remainder_piby2@PLT
+
+   mov      p_temp(%rsp), %r11
+   mov      $1, %r8d                                  # for determining region later on
+   movsd    r(%rsp), %xmm0                            # x
+   movsd    rr(%rsp), %xmm4                           # xx
+   mov      region(%rsp), %eax                        # region
+
+# xmm0 = x, xmm4 = xx, r8d = 1, eax= region
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+# perform taylor series to calc sinx, sinx
+.Lsin_piby4:
+#  x2 = r * r;
+
+#xmm4 = a part of rr for the sin path, xmm4 is overwritten in the sin path
+#instead use xmm3 because that was freed up in the sin path, xmm3 is overwritten in sin path
+   movsd    %xmm0, %xmm3
+   movsd    %xmm0, %xmm2
+   mulsd    %xmm0, %xmm2                              # x2
+
+##      if region is 0 or 2   do a sin calc.
+   and      %eax, %r8d
+   jnz      .Lcosregion
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# region 0 or 2 do a sin calculation
+   movsd    .Lsinarray+0x50(%rip), %xmm3              # s6
+   mulsd    %xmm2, %xmm3                              # x2s6
+   movsd    .Lsinarray+0x20(%rip), %xmm5              # s3
+   movsd    %xmm4,p_temp(%rsp)                        # store xx
+   movsd    %xmm2, %xmm1                              # move for x4
+   mulsd    %xmm2, %xmm1                              # x4
+   movsd    %xmm0,p_temp1(%rsp)                       # store x
+   mulsd    %xmm2, %xmm5                              # x2s3
+   movsd    %xmm0, %xmm4                              # move for x3
+   addsd    .Lsinarray+0x40(%rip), %xmm3              # s5+x2s6
+   mulsd    %xmm2, %xmm1                              # x6
+   mulsd    %xmm2, %xmm3                              # x2(s5+x2s6)
+   mulsd    %xmm2, %xmm4                              # x3
+   addsd    .Lsinarray+0x10(%rip), %xmm5              # s2+x2s3
+   mulsd    %xmm2, %xmm5                              # x2(s2+x2s3)
+   addsd    .Lsinarray+0x30(%rip), %xmm3              # s4 + x2(s5+x2s6)
+   mulsd    .L__real_3fe0000000000000(%rip), %xmm2    # 0.5 *x2
+   movsd    p_temp(%rsp), %xmm0                       # load xx
+   mulsd    %xmm1, %xmm3                              # x6(s4 + x2(s5+x2s6))
+   addsd    .Lsinarray(%rip), %xmm5                   # s1+x2(s2+x2s3)
+   mulsd    %xmm0, %xmm2                              # 0.5 * x2 *xx
+   addsd    %xmm5, %xmm3                              # zs
+   mulsd    %xmm3, %xmm4                              # *x3
+   subsd    %xmm2, %xmm4                              # x3*zs - 0.5 * x2 *xx
+   addsd    %xmm4, %xmm0                              # +xx
+   addsd    p_temp1(%rsp), %xmm0                      # +x
+   jmp      .Ladjust_region
+
+.align 16
+.Lcosregion:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# region 1 or 3    - do a cos calculation
+#  zc = (c2 + x2 * (c3 + x2 * (c4 + x2 * (c5 + x2 * c6))));
+   mulsd    %xmm0, %xmm4                              # x*xx
+   movsd    .L__real_3fe0000000000000(%rip), %xmm5
+   movsd    .Lcosarray+0x50(%rip), %xmm1              # c6
+   movsd    .Lcosarray+0x20(%rip), %xmm0              # c3
+   mulsd    %xmm2, %xmm5                              # r = 0.5 *x2
+   movsd    %xmm2, %xmm3                              # copy of x2
+   movsd    %xmm4,p_temp(%rsp)                        # store x*xx
+   mulsd    %xmm2, %xmm1                              # c6*x2
+   mulsd    %xmm2, %xmm0                              # c3*x2
+   subsd    .L__real_3ff0000000000000(%rip), %xmm5    # -t=r-1.0   ;trash r
+   mulsd    %xmm2, %xmm3                              # x4
+   addsd    .Lcosarray+0x40(%rip), %xmm1              # c5+x2c6
+   addsd    .Lcosarray+0x10(%rip), %xmm0              # c2+x2C3
+   addsd    .L__real_3ff0000000000000(%rip), %xmm5    # 1 + (-t)   ;trash t
+   mulsd    %xmm2, %xmm3                              # x6
+   mulsd    %xmm2, %xmm1                              # x2(c5+x2c6)
+   mulsd    %xmm2, %xmm0                              # x2(c2+x2C3)
+   movsd    %xmm2, %xmm4                              # copy of x2
+   mulsd    .L__real_3fe0000000000000(%rip), %xmm4    # r recalculate
+   addsd    .Lcosarray+0x30(%rip), %xmm1              # c4 + x2(c5+x2c6)
+   addsd    .Lcosarray(%rip), %xmm0                   # c1+x2(c2+x2C3)
+   mulsd    %xmm2, %xmm2                              # x4 recalculate
+   subsd    %xmm4, %xmm5                              # (1 + (-t)) - r
+   mulsd    %xmm3, %xmm1                              # x6(c4 + x2(c5+x2c6))
+   addsd    %xmm1, %xmm0                              # zc
+   subsd    .L__real_3ff0000000000000(%rip), %xmm4    # t relaculate
+   subsd    p_temp(%rsp), %xmm5                       # ((1 + (-t)) - r) - x*xx
+   mulsd    %xmm2, %xmm0                              # x4 * zc
+   addsd    %xmm5, %xmm0                              # x4 * zc + ((1 + (-t)) - r -x*xx)
+   subsd    %xmm4, %xmm0                              # result - (-t)
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+.align 16
+.Ladjust_region:      # positive or negative
+#      switch (region)
+   shr      $1, %eax
+   mov      %eax, %ecx
+   and      %r11d, %eax
+   not      %ecx
+   not      %r11d
+   and      %r11d, %ecx
+   or       %ecx, %eax
+   and      $1, %eax
+   jnz      .Lsin_cleanup
+
+## if the original region 0, 1 and arg is negative, then we negate the result.
+## if the original region 2, 3 and arg is positive, then we negate the result.
+   movsd    %xmm0, %xmm2
+   xorpd    %xmm0, %xmm0
+   subsd    %xmm2, %xmm0
+
+.align 16
+.Lsin_cleanup:
+   add      $stack_size, %rsp
+   ret
+
+.align 16
+.Lsin_naninf:
+   call     fname_special
+   add      $stack_size, %rsp
+   ret
+
+
+
diff --git a/src/gas/sincos.S b/src/gas/sincos.S
new file mode 100644
index 0000000..6558f9e
--- /dev/null
+++ b/src/gas/sincos.S
@@ -0,0 +1,616 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#
+# An implementation of the sincos function.
+#
+# Prototype:
+#
+#   void sincos(double x, double* sinr, double* cosr);
+#
+#   Computes sincos
+#   It will provide proper C99 return values,
+#   but may not raise floating point status bits properly.
+#   Based on the NAG C implementation.
+#
+#
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.data
+.align 16
+.L__real_7fffffffffffffff: .quad 0x07fffffffffffffff  #Sign bit zero
+                        .quad 0                       # for alignment
+.L__real_3ff0000000000000: .quad 0x03ff0000000000000  # 1.0
+                        .quad 0                          
+.L__real_3fe0000000000000: .quad 0x03fe0000000000000  # 0.5
+                        .quad 0
+.L__real_3fc5555555555555: .quad 0x03fc5555555555555  # 0.166666666666
+                        .quad 0
+.L__real_3fe45f306dc9c883: .quad 0x03fe45f306dc9c883  # twobypi
+                        .quad 0
+.L__real_3ff921fb54400000: .quad 0x03ff921fb54400000  # piby2_1
+                        .quad 0
+.L__real_3dd0b4611a626331: .quad 0x03dd0b4611a626331  # piby2_1tail
+                        .quad 0
+.L__real_3dd0b4611a600000: .quad 0x03dd0b4611a600000  # piby2_2
+                        .quad 0
+.L__real_3ba3198a2e037073: .quad 0x03ba3198a2e037073  # piby2_2tail
+                        .quad 0                
+.L__real_fffffffff8000000: .quad 0x0fffffffff8000000  # mask for stripping head and tail
+                        .quad 0                
+.L__real_411E848000000000: .quad 0x415312d000000000   # 5e6 0x0411E848000000000  # 5e5
+                        .quad 0
+
+.align 16
+.Lsincosarray:
+    .quad    0x0bfc5555555555555                      # -0.16666666666666666    s1
+    .quad    0x03fa5555555555555                      # 0.041666666666666664    c1   
+    .quad    0x03f81111111110bb3                      # 0.00833333333333095     s2
+    .quad    0x0bf56c16c16c16967                      # -0.0013888888888887398  c2
+    .quad    0x0bf2a01a019e83e5c                      # -0.00019841269836761127 s3
+    .quad    0x03efa01a019f4ec90                      # 2.4801587298767041E-05  c3
+    .quad    0x03ec71de3796cde01                      # 2.7557316103728802E-06  s4
+    .quad    0x0be927e4fa17f65f6                      # -2.7557317272344188E-07 c4
+    .quad    0x0be5ae600b42fdfa7                      # -2.5051132068021698E-08 s5
+    .quad    0x03e21eeb69037ab78                      # 2.0876146382232963E-09  c6
+    .quad    0x03de5e0b2f9a43bb8                      # 1.5918144304485914E-10  s6
+    .quad    0x0bda907db46cc5e42                      # -1.1382639806794487E-11 c7
+
+.align 16
+.Lcossinarray:
+    .quad    0x03fa5555555555555                      # 0.0416667        c1
+    .quad    0x0bfc5555555555555                      # -0.166667        s1
+    .quad    0x0bf56c16c16c16967
+    .quad    0x03f81111111110bb3                      # 0.00833333       s2
+    .quad    0x03efa01a019f4ec90
+    .quad    0x0bf2a01a019e83e5c                      # -0.000198413     s3
+    .quad    0x0be927e4fa17f65f6
+    .quad    0x03ec71de3796cde01                      # 2.75573e-006     s4
+    .quad    0x03e21eeb69037ab78
+    .quad    0x0be5ae600b42fdfa7                      # -2.50511e-008    s5
+    .quad    0x0bda907db46cc5e42
+    .quad    0x03de5e0b2f9a43bb8                      # 1.59181e-010     s6
+
+.text
+.align 16
+.p2align 4,,15
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(sincos)
+#define fname_special _sincos_special@PLT
+    
+# define local variable storage offsets
+.equ    p_temp,    0x30                               # temporary for get/put bits operation
+.equ    p_temp1,   0x40                               # temporary for get/put bits operation
+.equ    r,         0x50                               # pointer to r for amd_remainder_piby2
+.equ    rr,        0x60                               # pointer to rr for amd_remainder_piby2
+.equ    region,    0x70                               # pointer to region for amd_remainder_piby2
+.equ   stack_size, 0x98
+
+.globl fname
+.type  fname,@function
+
+fname:
+    sub     $stack_size, %rsp
+    xorpd   %xmm2,%xmm2                               # zeroed out for later use
+
+# GET_BITS_DP64(x, ux);
+# get the input value to an integer register.
+    movsd   %xmm0,p_temp(%rsp)
+    mov     p_temp(%rsp),%rcx                         # rcx is ux
+
+##  if NaN or inf
+    mov     $0x07ff0000000000000,%rax
+    mov     %rax,%r10
+    and     %rcx,%r10
+    cmp     %rax,%r10
+    jz      .Lsincos_naninf
+
+#  ax = (ux & ~SIGNBIT_DP64);
+    mov     $0x07fffffffffffffff,%r10
+    and     %rcx,%r10                # r10 is ax
+
+##  if (ax <= 0x3fe921fb54442d18) /* abs(x) <= pi/4 */
+    mov     $0x03fe921fb54442d18,%rax
+    cmp     %rax,%r10
+    jg      .Lsincos_reduce
+
+##      if (ax < 0x3f20000000000000) /* abs(x) < 2.0^(-13) */
+    mov     $0x03f20000000000000,%rax
+    cmp     %rax,%r10
+    jge     .Lsincos_small
+
+##          if (ax < 0x3e40000000000000) /* abs(x) < 2.0^(-27) */
+    mov     $0x03e40000000000000,%rax
+    cmp     %rax,%r10
+    jge     .Lsincos_smaller
+
+                            # sin = x;
+    movsd   .L__real_3ff0000000000000(%rip),%xmm1     # cos = 1.0;
+    jmp     .Lsincos_cleanup   
+
+##          else
+.align 32
+.Lsincos_smaller:
+#              sin = x - x^3 * 0.1666666666666666666;
+#              cos = 1.0 - x*x*0.5;
+
+    movsd   %xmm0,%xmm2
+    movsd   .L__real_3fc5555555555555(%rip),%xmm4     # 0.1666666666666666666
+    mulsd   %xmm2,%xmm2                               # x^2
+    movsd   .L__real_3ff0000000000000(%rip),%xmm1     # 1.0
+    movsd   %xmm2,%xmm3                               # copy of x^2
+
+    mulsd   %xmm0,%xmm2                               # x^3
+    mulsd   .L__real_3fe0000000000000(%rip),%xmm3     # 0.5 * x^2
+    mulsd   %xmm4,%xmm2                               # x^3 * 0.1666666666666666666
+    subsd   %xmm2,%xmm0                               # x - x^3 * 0.1666666666666666666, sin
+    subsd   %xmm3,%xmm1                               # 1 - 0.5 * x^2, cos
+
+    jmp     .Lsincos_cleanup                
+
+
+##      else
+
+.align 16
+.Lsincos_small:
+#          sin = sin_piby4(x, 0.0);
+    movsd   .L__real_3fe0000000000000(%rip),%xmm5     # .5
+
+#  x2 = r * r;
+    movsd   %xmm0,%xmm2
+    mulsd   %xmm0,%xmm2                               # x2
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# region 0 or 2     - do a sin calculation
+#  zs = (s2 + x2 * (s3 + x2 * (s4 + x2 * (s5 + x2 * s6))));
+
+    movlhps %xmm2,%xmm2
+    movapd  .Lsincosarray+0x50(%rip),%xmm3            # s6
+    movapd  %xmm2,%xmm1                               # move for x4
+    movdqa  .Lsincosarray+0x20(%rip),%xmm5            # s3
+    mulpd   %xmm2,%xmm3                               # x2s6
+    addpd   .Lsincosarray+0x40(%rip),%xmm3            # s5+x2s6
+    mulpd   %xmm2,%xmm5                               # x2s3
+    movapd  %xmm4,p_temp(%rsp)                        # rr move to to memory
+    mulpd   %xmm2,%xmm1                               # x4
+    mulpd   %xmm2,%xmm3                               # x2(s5+x2s6)
+    addpd   .Lsincosarray+0x10(%rip),%xmm5            # s2+x2s3
+    movapd  %xmm1,%xmm4                               # move for x6
+    addpd   .Lsincosarray+0x30(%rip),%xmm3            # s4 + x2(s5+x2s6)
+    mulpd   %xmm2,%xmm5                               # x2(s2+x2s3)
+    mulpd   %xmm2,%xmm4                               # x6
+    addpd   .Lsincosarray(%rip),%xmm5                 # s1+x2(s2+x2s3)
+    mulpd   %xmm4,%xmm3                               # x6(s4 + x2(s5+x2s6))
+
+    movsd   %xmm2,%xmm4                               # xmm4 = x2 for 0.5x2 for cos
+                                                      # xmm2 contains x2 for x3 for sin
+    addpd   %xmm5,%xmm3                               # zs in lower and zc upper
+
+    mulsd   %xmm0,%xmm2                               # xmm2=x3 for sin
+
+    movhlps %xmm3,%xmm5                               # Copy z, xmm5 = cos , xmm3 = sin
+
+    mulsd   .L__real_3fe0000000000000(%rip),%xmm4     # xmm4=r=0.5*x2 for cos term
+    mulsd   %xmm2,%xmm3                               # sin *x3
+    mulsd   %xmm1,%xmm5                               # cos *x4
+    movsd   .L__real_3ff0000000000000(%rip),%xmm2     # 1.0
+    subsd   %xmm4,%xmm2                               # t=1.0-r
+    movsd   .L__real_3ff0000000000000(%rip),%xmm1     # 1.0
+    subsd   %xmm2,%xmm1                               # 1 - t
+    subsd   %xmm4,%xmm1                               # (1-t) -r
+    addsd   %xmm5,%xmm1                               # ((1-t) -r) + cos
+    addsd   %xmm3,%xmm0                               # xmm0= sin+x, final sin term
+    addsd   %xmm2,%xmm1                               # xmm1 = t +{ ((1-t) -r) + cos}, final cos term
+
+    jmp     .Lsincos_cleanup
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lsincos_reduce:
+# change rdx to rcx and r8 to r9
+# rcx= ux, r10 = ax
+# %r9,%rax are free
+
+#  xneg = (ax != ux);
+    cmp     %r10,%rcx
+    mov     $0,%r11d
+
+##  if (xneg) x = -x;
+    jz      .LPositive
+    mov     $1,%r11d
+    subsd   %xmm0,%xmm2
+    movsd   %xmm2,%xmm0
+
+# rcx= ux, r10 = ax, r11= Sign
+# %r9,%rax are free
+# change rdx to rcx and r8 to r9
+
+.align 16
+.LPositive:
+##  if (x < 5.0e5)
+    cmp     .L__real_411E848000000000(%rip),%r10
+    jae     .Lsincos_reduce_precise
+
+# reduce  the argument to be in a range from -pi/4 to +pi/4
+# by subtracting multiples of pi/2
+    movsd   %xmm0,%xmm2
+    movsd   .L__real_3fe45f306dc9c883(%rip),%xmm3     # twobypi
+    movsd   %xmm0,%xmm4
+    movsd   .L__real_3fe0000000000000(%rip),%xmm5     # .5
+    mulsd   %xmm3,%xmm2
+
+#/* How many pi/2 is x a multiple of? */
+#       xexp  = ax >> EXPSHIFTBITS_DP64;
+    shr     $52,%r10                                  # >>EXPSHIFTBITS_DP64
+
+#       npi2  = (int)(x * twobypi + 0.5);
+    addsd   %xmm5,%xmm2                               # npi2
+
+    movsd   .L__real_3ff921fb54400000(%rip),%xmm3     # piby2_1
+    cvttpd2dq    %xmm2,%xmm0                          # convert to integer
+    movsd   .L__real_3dd0b4611a626331(%rip),%xmm1     # piby2_1tail
+    cvtdq2pd    %xmm0,%xmm2                           # and back to float.
+
+#       /* Subtract the multiple from x to get an extra-precision remainder */
+#       rhead  = x - npi2 * piby2_1;
+    mulsd   %xmm2,%xmm3
+    subsd   %xmm3,%xmm4                               # rhead
+
+#       rtail  = npi2 * piby2_1tail;
+    mulsd   %xmm2,%xmm1
+    movd    %xmm0,%eax
+
+
+#       GET_BITS_DP64(rhead-rtail, uy);                   ; originally only rhead
+    movsd   %xmm4,%xmm0
+    subsd   %xmm1,%xmm0
+
+    movsd   .L__real_3dd0b4611a600000(%rip),%xmm3     # piby2_2
+    movsd   %xmm0,p_temp(%rsp)
+    movsd   .L__real_3ba3198a2e037073(%rip),%xmm5     # piby2_2tail
+    mov     %eax,%ecx
+    mov     p_temp(%rsp),%r9                          # rcx is rhead-rtail
+
+#    xmm0=r, xmm4=rhead, xmm1=rtail, xmm2=npi2, xmm3=temp for calc, xmm5= temp for calc
+#       expdiff = xexp - ((uy & EXPBITS_DP64) >> EXPSHIFTBITS_DP64);
+    shl     $1,%r9                                    # strip any sign bit
+    shr     $53,%r9                                   # >> EXPSHIFTBITS_DP64 +1
+    sub     %r9,%r10                                  # expdiff
+
+##       if (expdiff > 15)
+    cmp     $15,%r10
+    jle     .Lexpdiff15
+
+#          /* The remainder is pretty small compared with x, which
+#             implies that x is a near multiple of pi/2
+#             (x matches the multiple to at least 15 bits) */
+
+#          t  = rhead;
+    movsd   %xmm4,%xmm1
+
+#          rtail  = npi2 * piby2_2;
+    mulsd   %xmm2,%xmm3
+
+#          rhead  = t - rtail;
+    mulsd   %xmm2,%xmm5                               # npi2 * piby2_2tail
+    subsd   %xmm3,%xmm4                               # rhead
+
+#          rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+    subsd   %xmm4,%xmm1                               # t - rhead
+    subsd   %xmm3,%xmm1                               # -rtail
+    subsd   %xmm1,%xmm5                               # rtail
+
+#      r = rhead - rtail;
+    movsd   %xmm4,%xmm0
+
+#HARSHA
+#xmm1=rtail
+    movsd   %xmm5,%xmm1
+    subsd   %xmm5,%xmm0
+    
+#    xmm0=r, xmm4=rhead, xmm1=rtail
+.Lexpdiff15:
+#      region = npi2 & 3;
+
+    subsd   %xmm0,%xmm4                               # rhead-r
+    subsd   %xmm1,%xmm4                               # rr = (rhead-r) - rtail
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+## if the input was close to a pi/2 multiple
+# The original NAG code missed this trick.  If the input is very close to n*pi/2 after
+# reduction,
+# then the sin is ~ 1.0 , to within 53 bits, when r is < 2^-27.  We already
+# have x at this point, so we can skip the sin polynomials.
+
+    cmp     $0x03f2,%r9                               # if r  small.
+    jge     .Lcossin_piby4                            # use taylor series if not
+    cmp     $0x03de,%r9                               # if r really small.
+    jle     .Lr_small                                 # then sin(r) = 0
+
+    movsd   %xmm0,%xmm2
+    mulsd   %xmm2,%xmm2                               # x^2
+
+##      if region is 0 or 2 do a sin calc.
+    and     $1,%ecx
+    jnz     .Lregion13
+
+# region 0 or 2 do a sincos calculation
+# use simply polynomial
+#              sin=x - x*x*x*0.166666666666666666;
+    movsd   .L__real_3fc5555555555555(%rip),%xmm3     # 0.166666666
+    mulsd   %xmm0,%xmm3                               # * x
+    mulsd   %xmm2,%xmm3                               # * x^2
+    subsd   %xmm3,%xmm0                               # xs
+#              cos=1.0 - x*x*0.5;
+    movsd   .L__real_3ff0000000000000(%rip),%xmm1     # 1.0
+    mulsd   .L__real_3fe0000000000000(%rip),%xmm2     # 0.5 *x^2
+    subsd   %xmm2,%xmm1                               # xc
+
+    jmp     .Ladjust_region
+
+.align 16
+.Lregion13:
+# region 1 or 3 do a cossin calculation
+# use simply polynomial
+#              sin=x - x*x*x*0.166666666666666666;
+    movsd   %xmm0,%xmm1
+
+    movsd   .L__real_3fc5555555555555(%rip),%xmm3     # 0.166666666
+    mulsd   %xmm0,%xmm3                               # 0.166666666* x
+    mulsd   %xmm2,%xmm3                               # 0.166666666* x * x^2
+    subsd   %xmm3,%xmm1                               # xs
+#              cos=1.0 - x*x*0.5;
+    movsd   .L__real_3ff0000000000000(%rip),%xmm0     # 1.0
+    mulsd   .L__real_3fe0000000000000(%rip),%xmm2     # 0.5 *x^2
+    subsd   %xmm2,%xmm0                               # xc
+
+    jmp     .Ladjust_region
+
+.align 16
+.Lr_small:
+##      if region is 0 or 2    do a sincos calc.
+    movsd   .L__real_3ff0000000000000(%rip),%xmm1     # cos(r) is a 1
+    and     $1,%ecx
+    jz      .Ladjust_region
+
+##      if region is 1 or 3    do a cossin calc.
+    movsd   %xmm0,%xmm1                               # sin(r) is r
+    movsd   .L__real_3ff0000000000000(%rip),%xmm0     # cos(r) is a 1
+    jmp     .Ladjust_region
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lsincos_reduce_precise:
+#      // Reduce x into range [-pi/4,pi/4]
+#      __amd_remainder_piby2(x, &r, &rr, &region);
+
+    mov     %rdi, p_temp1(%rsp)
+    mov     %rsi, p_temp1+8(%rsp)
+    mov     %r11,p_temp(%rsp)
+
+    lea     region(%rsp),%rdx
+    lea     rr(%rsp),%rsi
+    lea     r(%rsp),%rdi
+    
+    call    __amd_remainder_piby2@PLT
+
+    mov     p_temp1(%rsp), %rdi
+    mov     p_temp1+8(%rsp), %rsi
+    mov     p_temp(%rsp),%r11
+
+    movsd   r(%rsp),%xmm0                             # x
+    movsd   rr(%rsp),%xmm4                            # xx
+    mov     region(%rsp),%eax                         # region to classify for sin/cos calc
+    mov     %eax,%ecx                                 # region to get sign
+
+# xmm0 = x, xmm4 = xx, r8d = 1, eax= region
+.align 16
+.Lcossin_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# perform taylor series to calc sinx, sinx
+#  x2 = r * r;
+#xmm4 = a part of rr for the sin path, xmm4 is overwritten in the sin path
+#instead use xmm3 because that was freed up in the sin path, xmm3 is overwritten in sin path
+
+    movsd   %xmm0,%xmm2
+    mulsd   %xmm0,%xmm2                               #x2
+
+##      if region is 0 or 2    do a sincos calc.
+    and     $1,%ecx
+    jz      .Lsincos02
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# region 1 or 3     - do a cossin calculation
+#  zc = (c2 + x2 * (c3 + x2 * (c4 + x2 * (c5 + x2 * c6))));
+
+
+    movlhps %xmm2,%xmm2
+
+    movapd  .Lcossinarray+0x50(%rip),%xmm3            # s6
+    movapd  %xmm2,%xmm1                               # move for x4
+    movdqa  .Lcossinarray+0x20(%rip),%xmm5            # s3
+    mulpd   %xmm2,%xmm3                               # x2s6
+    addpd   .Lcossinarray+0x40(%rip),%xmm3            # s5+x2s6
+    mulpd   %xmm2,%xmm5                               # x2s3
+    movsd   %xmm4,p_temp(%rsp)                        # rr move to to memory
+    mulpd   %xmm2,%xmm1                               # x4
+    mulpd   %xmm2,%xmm3                               # x2(s5+x2s6)
+    addpd   .Lcossinarray+0x10(%rip),%xmm5            # s2+x2s3
+    movapd  %xmm1,%xmm4                               # move for x6
+    addpd   .Lcossinarray+0x30(%rip),%xmm3            # s4 + x2(s5+x2s6)
+    mulpd   %xmm2,%xmm5                               # x2(s2+x2s3)
+    mulpd   %xmm2,%xmm4                               # x6
+    addpd   .Lcossinarray(%rip),%xmm5                 # s1+x2(s2+x2s3)
+    mulpd   %xmm4,%xmm3                               # x6(s4 + x2(s5+x2s6))
+
+    movsd   %xmm2,%xmm4                               # xmm4 = x2 for 0.5x2 cos
+                                                      # xmm2 contains x2 for x3 sin
+
+    addpd   %xmm5,%xmm3                               # zc in lower and zs in upper
+
+    mulsd   %xmm0,%xmm2                               # xmm2=x3 for the sin term
+
+    movhlps %xmm3,%xmm5                               # Copy z, xmm5 = sin, xmm3 = cos
+    mulsd   .L__real_3fe0000000000000(%rip),%xmm4     # xmm4=r=0.5*x2 for cos term
+
+    mulsd   %xmm2,%xmm5                               # sin *x3
+    mulsd   %xmm1,%xmm3                               # cos *x4
+    movsd   %xmm0,p_temp1(%rsp)                       # store x
+    movsd   %xmm0,%xmm1
+
+    movsd   .L__real_3ff0000000000000(%rip),%xmm2     # 1.0
+    subsd   %xmm4,%xmm2                               # t=1.0-r
+
+    movsd   .L__real_3ff0000000000000(%rip),%xmm0     # 1.0
+    subsd   %xmm2,%xmm0                               # 1 - t
+
+    mulsd   p_temp(%rsp),%xmm1                        # x*xx
+    subsd   %xmm4,%xmm0                               # (1-t) -r
+    subsd   %xmm1,%xmm0                               # ((1-t) -r) - x *xx
+
+    mulsd   p_temp(%rsp),%xmm4                        # 0.5*x2*xx
+
+    addsd   %xmm3,%xmm0                               # (((1-t) -r) - x *xx) + cos
+
+    subsd   %xmm4,%xmm5                               # sin - 0.5*x2*xx
+
+    addsd   %xmm2,%xmm0                               # xmm0 = t +{ (((1-t) -r) - x *xx) + cos}, final cos term
+
+    addsd   p_temp(%rsp),%xmm5                        # sin + xx
+    movsd   p_temp1(%rsp),%xmm1                       # load x
+    addsd   %xmm5,%xmm1                               # xmm1= sin+x, final sin term
+
+    jmp     .Ladjust_region
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lsincos02:
+# region 0 or 2 do a sincos calculation
+    movlhps %xmm2,%xmm2
+
+    movapd  .Lsincosarray+0x50(%rip),%xmm3            # s6
+    movapd  %xmm2,%xmm1                               # move for x4
+    movdqa  .Lsincosarray+0x20(%rip),%xmm5            # s3
+    mulpd   %xmm2,%xmm3                               # x2s6
+    addpd   .Lsincosarray+0x40(%rip),%xmm3            # s5+x2s6
+    mulpd   %xmm2,%xmm5                               # x2s3
+    movsd   %xmm4,p_temp(%rsp)                        # rr move to to memory
+    mulpd   %xmm2,%xmm1                               # x4
+    mulpd   %xmm2,%xmm3                               # x2(s5+x2s6)
+    addpd   .Lsincosarray+0x10(%rip),%xmm5            # s2+x2s3
+    movapd  %xmm1,%xmm4                               # move for x6
+    addpd   .Lsincosarray+0x30(%rip),%xmm3            # s4 + x2(s5+x2s6)
+    mulpd   %xmm2,%xmm5                               # x2(s2+x2s3)
+    mulpd   %xmm2,%xmm4                               # x6
+    addpd   .Lsincosarray(%rip),%xmm5                 # s1+x2(s2+x2s3)
+    mulpd   %xmm4,%xmm3                               # x6(s4 + x2(s5+x2s6))
+
+    movsd   %xmm2,%xmm4                               # xmm4 = x2 for 0.5x2 for cos
+                                                      # xmm2 contains x2 for x3 for sin
+
+    addpd   %xmm5,%xmm3                               # zs in lower and zc in upper
+
+    mulsd   %xmm0,%xmm2                               # xmm2=x3 for sin
+
+    movhlps %xmm3,%xmm5                               # Copy z, xmm5 = cos , xmm3 = sin
+
+    mulsd   .L__real_3fe0000000000000(%rip),%xmm4     # xmm4=r=0.5*x2 for cos term
+
+    mulsd   %xmm2,%xmm3                               # sin *x3
+    mulsd   %xmm1,%xmm5                               # cos *x4
+
+    movsd   .L__real_3ff0000000000000(%rip),%xmm2     # 1.0
+    subsd   %xmm4,%xmm2                               # t=1.0-r
+
+    movsd   .L__real_3ff0000000000000(%rip),%xmm1     # 1.0
+    subsd   %xmm2,%xmm1                               # 1 - t
+
+    movsd   %xmm0,p_temp1(%rsp)                       # store x
+    mulsd   p_temp(%rsp),%xmm0                        # x*xx
+
+    subsd   %xmm4,%xmm1                               # (1-t) -r
+    subsd   %xmm0,%xmm1                               # ((1-t) -r) - x *xx
+
+    mulsd   p_temp(%rsp),%xmm4                        # 0.5*x2*xx
+
+    addsd   %xmm5,%xmm1                               # (((1-t) -r) - x *xx) + cos
+
+    subsd   %xmm4,%xmm3                               # sin - 0.5*x2*xx
+
+    addsd   %xmm2,%xmm1                               # xmm1 = t +{ (((1-t) -r) - x *xx) + cos}, final cos term
+
+    addsd   p_temp(%rsp),%xmm3                        # sin + xx
+    movsd   p_temp1(%rsp),%xmm0                       # load x
+    addsd   %xmm3,%xmm0                               # xmm0= sin+x, final sin term
+
+    jmp     .Ladjust_region
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#      switch (region)
+.align 16
+.Ladjust_region:        # positive or negative for sin return val in xmm0
+
+    mov     %eax,%r9d
+
+    shr     $1,%eax
+    mov     %eax,%ecx
+    and     %r11d,%eax
+
+    not     %ecx
+    not     %r11d
+    and     %r11d,%ecx
+
+    or      %ecx,%eax
+    and     $1,%eax
+    jnz     .Lcos_sign
+
+## if the original region 0, 1 and arg is negative, then we negate the result.
+## if the original region 2, 3 and arg is positive, then we negate the result.
+    movsd   %xmm0,%xmm2
+    xorpd   %xmm0,%xmm0
+    subsd   %xmm2,%xmm0
+
+.Lcos_sign:            # positive or negative for cos return val in xmm1
+    add     $1,%r9
+    and     $2,%r9d
+    jz      .Lsincos_cleanup
+## if the original region 1 or 2 then we negate the result.
+    movsd   %xmm1,%xmm2
+    xorpd   %xmm1,%xmm1
+    subsd   %xmm2,%xmm1
+
+#.align 16
+.Lsincos_cleanup:
+    movsd   %xmm0, (%rdi)                             # save the sin
+    movsd   %xmm1, (%rsi)                             # save the cos
+
+    add     $stack_size,%rsp
+    ret
+
+.align 16
+.Lsincos_naninf:
+   call     fname_special
+   add      $stack_size, %rsp
+   ret
+
diff --git a/src/gas/sincosf.S b/src/gas/sincosf.S
new file mode 100644
index 0000000..dcdbe9a
--- /dev/null
+++ b/src/gas/sincosf.S
@@ -0,0 +1,402 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#
+# An implementation of the sincosf function.
+#
+# Prototype:
+#
+#     void fastsincosf(float x, float * sinfx, float * cosfx);
+#
+#   Computes sinf(x) and cosf(x).  
+#   It will provide proper C99 return values,
+#   but may not raise floating point status bits properly.
+#   Based on the NAG C implementation.
+#   Author: Harsha Jagasia
+#   Email:  harsha.jagasia@amd.com
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.data
+.align 32
+.L__real_3ff0000000000000: .quad 0x03ff0000000000000  # 1.0
+                        .quad 0                       # for alignment
+.L__real_3fe0000000000000: .quad 0x03fe0000000000000  # 0.5
+                        .quad 0
+.L__real_3fc5555555555555: .quad 0x03fc5555555555555  # 0.166666666666
+                        .quad 0
+.L__real_3fe45f306dc9c883: .quad 0x03fe45f306dc9c883  # twobypi
+                        .quad 0
+.L__real_3FF921FB54442D18: .quad 0x03FF921FB54442D18  # piby2
+                        .quad 0
+.L__real_3ff921fb54400000: .quad 0x03ff921fb54400000  # piby2_1
+                        .quad 0
+.L__real_3dd0b4611a626331: .quad 0x03dd0b4611a626331  # piby2_1tail
+                        .quad 0
+.L__real_3dd0b4611a600000: .quad 0x03dd0b4611a600000  # piby2_2
+                        .quad 0
+.L__real_3ba3198a2e037073: .quad 0x03ba3198a2e037073  # piby2_2tail
+                        .quad 0                                        
+.L__real_fffffffff8000000: .quad 0x0fffffffff8000000  # mask for stripping head and tail
+                        .quad 0               
+.L__real_8000000000000000: .quad 0x08000000000000000  # -0  or signbit
+                        .quad 0
+.L__real_411E848000000000: .quad 0x415312d000000000   # 5e6 0x0411E848000000000  # 5e5
+                        .quad 0
+
+.align 32
+.Lcsarray:
+    .quad    0x0bfc5555555555555                      # -0.166667           s1
+    .quad    0x03fa5555555555555                      # 0.0416667           c1
+    .quad    0x03f81111111110bb3                      # 0.00833333          s2
+    .quad    0x0bf56c16c16c16967                      # -0.00138889         c2
+    .quad    0x0bf2a01a019e83e5c                      # -0.000198413        s3
+    .quad    0x03efa01a019f4ec90                      # 2.48016e-005        c3
+    .quad    0x03ec71de3796cde01                      # 2.75573e-006        s4
+    .quad    0x0be927e4fa17f65f6                      # -2.75573e-007       c4
+    .quad    0x0be5ae600b42fdfa7                      # -2.50511e-008       s5
+    .quad    0x03e21eeb69037ab78                      # 2.08761e-009        c5
+    .quad    0x03de5e0b2f9a43bb8                      # 1.59181e-010        s6
+    .quad    0x0bda907db46cc5e42                      # -1.13826e-011       c6
+
+.text
+.align 16
+.p2align 4,,15
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(sincosf)
+#define fname_special _sincosf_special@PLT
+
+# define local variable storage offsets
+.equ   p_temp,     0x30                               # temporary for get/put bits operation
+.equ   p_temp1,    0x40                               # temporary for get/put bits operation
+.equ   p_temp2,    0x50                               # temporary for get/put bits operation
+.equ   p_temp3,    0x60                               # temporary for get/put bits operation
+.equ   region,     0x70                               # pointer to region for amd_remainder_piby2
+.equ   r,          0x80                               # pointer to r for amd_remainder_piby2
+.equ   stack_size, 0xa8
+
+.globl fname
+.type  fname,@function
+
+fname:
+    sub     $stack_size, %rsp
+
+    xorpd   %xmm2,%xmm2
+    
+#  GET_BITS_DP64(x, ux);
+# convert input to double.
+    cvtss2sd    %xmm0,%xmm0
+# get the input value to an integer register.
+    movsd   %xmm0,p_temp(%rsp)
+    mov     p_temp(%rsp),%rdx                         # rdx is ux
+
+##  if NaN or inf
+    mov     $0x07ff0000000000000,%rax
+    mov     %rax,%r10
+    and     %rdx,%r10
+    cmp     %rax,%r10
+    jz      .L__sc_naninf
+    
+#  ax = (ux & ~SIGNBIT_DP64);
+    mov     $0x07fffffffffffffff,%r10
+    and     %rdx,%r10                                 # r10 is ax
+
+##  if (ax <= 0x3fe921fb54442d18) /* abs(x) <= pi/4 */
+    mov     $0x03fe921fb54442d18,%rax
+    cmp     %rax,%r10
+    jg      .L__sc_reduce
+
+##          if (ax < 0x3f20000000000000) /* abs(x) < 2.0^(-13) */
+   mov      $0x3f20000000000000, %rax
+   cmp      %rax, %r10
+   jge      .L__sc_notsmallest
+
+#                  sinf = x, cos=1.0
+   movsd    .L__real_3ff0000000000000(%rip),%xmm1
+   jmp      .L__sc_cleanup
+   
+#          *s = sin_piby4(x, 0.0);
+#          *c = cos_piby4(x, 0.0);
+.L__sc_notsmallest:
+    xor     %eax,%eax                                 # region 0
+    mov     %r10,%rdx
+    movsd   .L__real_3fe0000000000000(%rip),%xmm5     # .5
+    jmp     .L__sc_piby4      
+
+.L__sc_reduce:    
+
+# reduce  the argument to be in a range from -pi/4 to +pi/4
+# by subtracting multiples of pi/2
+
+#  xneg = (ax != ux);
+    cmp     %r10,%rdx
+##  if (xneg) x = -x;
+    jz      .Lpositive
+    subsd   %xmm0,%xmm2
+    movsd   %xmm2,%xmm0
+
+.align 16
+.Lpositive:
+##  if (x < 5.0e5)
+    cmp     .L__real_411E848000000000(%rip),%r10
+    jae     .Lsincosf_reduce_precise
+
+    movsd   %xmm0,%xmm2
+    movsd   %xmm0,%xmm4
+
+    mulsd   .L__real_3fe45f306dc9c883(%rip),%xmm2     # twobypi
+    movsd   .L__real_3fe0000000000000(%rip),%xmm5     # .5 
+
+#/* How many pi/2 is x a multiple of? */
+#      xexp  = ax >> EXPSHIFTBITS_DP64;
+    mov     %r10,%r9
+    shr     $52,%r9                                   # >> EXPSHIFTBITS_DP64
+
+#        npi2  = (int)(x * twobypi + 0.5);
+    addsd   %xmm5,%xmm2                               # npi2
+
+    movsd   .L__real_3ff921fb54400000(%rip),%xmm3     # piby2_1
+    cvttpd2dq    %xmm2,%xmm0                          # convert to integer 
+    movsd   .L__real_3dd0b4611a626331(%rip),%xmm1     # piby2_1tail    
+    cvtdq2pd    %xmm0,%xmm2                           # and back to float.    
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+#      rhead  = x - npi2 * piby2_1;
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+#       rhead  = x - npi2 * piby2_1;
+
+    mulsd   %xmm2,%xmm3                               # use piby2_1
+    subsd   %xmm3,%xmm4                               # rhead
+
+#      rtail  = npi2 * piby2_1tail;
+    mulsd   %xmm2,%xmm1                               # rtail
+
+    movd    %xmm0,%eax
+
+#      GET_BITS_DP64(rhead-rtail, uy);               ; originally only rhead
+    movsd   %xmm4,%xmm0
+    subsd   %xmm1,%xmm0
+
+    movsd   .L__real_3dd0b4611a600000(%rip),%xmm3     # piby2_2
+    movsd   .L__real_3ba3198a2e037073(%rip),%xmm5     # piby2_2tail
+    movd    %xmm0,%rcx
+
+#      expdiff = xexp - ((uy & EXPBITS_DP64) >> EXPSHIFTBITS_DP64);
+    shl     $1,%rcx                                   # strip any sign bit
+    shr     $53,%rcx                                  # >> EXPSHIFTBITS_DP64 +1
+    sub     %rcx,%r9                                  # expdiff
+
+##      if (expdiff > 15)
+    cmp     $15,%r9
+    jle     .Lexpdiff15
+
+#          /* The remainder is pretty small compared with x, which
+#             implies that x is a near multiple of pi/2
+#             (x matches the multiple to at least 15 bits) */
+
+#          t  = rhead;
+    movsd   %xmm4,%xmm1
+
+#          rtail  = npi2 * piby2_2;
+    mulsd   %xmm2,%xmm3
+
+#          rhead  = t - rtail;
+    mulsd   %xmm2,%xmm5                               # npi2 * piby2_2tail
+    subsd   %xmm3,%xmm4                               # rhead
+
+#          rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+    subsd   %xmm4,%xmm1                               # t - rhead
+    subsd   %xmm3,%xmm1                               # -rtail
+    subsd   %xmm1,%xmm5                               # rtail
+
+#      r = rhead - rtail;
+    movsd   %xmm4,%xmm0
+
+#HARSHA
+#xmm1=rtail
+    movsd   %xmm5,%xmm1
+    subsd   %xmm5,%xmm0
+
+#      region = npi2 & 3;
+#    and    $3,%eax
+#    xmm0=r, xmm4=rhead, xmm1=rtail
+.Lexpdiff15:
+
+## if the input was close to a pi/2 multiple
+#
+
+    cmp     $0x03f2,%rcx                              # if r  small.
+    jge     .L__sc_piby4                              # use taylor series if not
+    cmp     $0x03de,%rcx                              # if r really small.
+    jle     .Lsinsmall                                # then sin(r) = r
+
+    movsd   %xmm0,%xmm2 
+    mulsd   %xmm2,%xmm2                               # x^2
+# use simply polynomial
+#              *s = x - x*x*x*0.166666666666666666;
+    movsd   .L__real_3fc5555555555555(%rip),%xmm3     # 
+    mulsd   %xmm0,%xmm3                               # * x
+    mulsd   %xmm2,%xmm3                               # * x^2
+    subsd   %xmm3,%xmm0                               # xs
+
+#              *c = 1.0 - x*x*0.5;
+    movsd   .L__real_3ff0000000000000(%rip),%xmm1     # 1.0
+    mulsd   .L__real_3fe0000000000000(%rip),%xmm2     # 0.5 *x^2
+    subsd   %xmm2,%xmm1
+    jmp     .L__adjust_region
+
+.Lsinsmall:                                           # then sin(r) = r
+    movsd   .L__real_3ff0000000000000(%rip),%xmm1     # cos(r) is a 1 
+    jmp     .L__adjust_region
+
+# perform taylor series to calc sinx, cosx
+#  COS
+#  x2 = x * x;
+#  return (1.0 - 0.5 * x2 + (x2 * x2 *
+#                            (c1 + x2 * (c2 + x2 * (c3 + x2 * c4)))));
+#  x2 = x * x;
+#  return (1.0 - 0.5 * x2 + (x2 * x2 *
+#                            (c1 + x2 * (c2 + x2 * (c3 + x2 * c4)))));                                                    
+#  SIN
+#  zc,zs = (c2 + x2 * (c3 + x2 * c4 ));
+#  xs =  r + x3 * (sc1 + x2 * zs);
+#  x2 = x * x;
+#  return (x + x * x2 * (c1 + x2 * (c2 + x2 * (c3 + x2 * c4))));
+# done with reducing the argument.  Now perform the sin/cos calculations.
+.align 16
+.L__sc_piby4:
+#  x2 = r * r;
+    movsd   .L__real_3fe0000000000000(%rip),%xmm5     # .5 
+    movsd   %xmm0,%xmm2
+    mulsd   %xmm0,%xmm2                               # x2
+    shufpd  $0,%xmm2,%xmm2                            # x2,x2
+    movsd   %xmm2,%xmm4
+    mulsd   %xmm4,%xmm4                               # x4
+    shufpd  $0,%xmm4,%xmm4                            # x4,x4
+
+#  x2m =    _mm_set1_pd (x2);
+#  zc,zs = (c2 + x2 * (c3 + x2 * c4 ));
+#    xs =  r + x3 * (sc1 + x2 * zs);
+#    xc =  t + ( x2 * x2 * (cc1 + x2 * zc));
+    movapd  .Lcsarray+0x30(%rip),%xmm1                # c4
+    movapd  .Lcsarray+0x10(%rip),%xmm3                # c2
+    mulpd   %xmm2,%xmm1                               # x2c4
+    mulpd   %xmm2,%xmm3                               # x2c2
+
+#  rc = 0.5 * x2;
+    mulsd   %xmm2,%xmm5                               #rc
+    mulsd   %xmm0,%xmm2                               #x3
+
+    addpd   .Lcsarray+0x20(%rip),%xmm1                # c3 + x2c4
+    addpd   .Lcsarray(%rip),%xmm3                     # c1 + x2c2
+    mulpd   %xmm4,%xmm1                               #    x4(c3 + x2c4)
+    addpd   %xmm3,%xmm1                               # c1 + x2c2 + x4(c3 + x2c4)
+
+#  -t = rc-1;
+    subsd   .L__real_3ff0000000000000(%rip),%xmm5     # 1.0  
+# now we have the poly for sin in the low half, and cos in upper half
+    mulsd   %xmm1,%xmm2                               # x3(sin poly)
+    shufpd  $3,%xmm1,%xmm1                            # get cos poly to low half of register
+    mulsd   %xmm4,%xmm1                               # x4(cos poly)
+
+    addsd   %xmm2,%xmm0                               # sin = r+...
+    subsd   %xmm5,%xmm1                               # cos = poly-(-t)
+
+.L__adjust_region:                                    # xmm0 is sin, xmm1 is cos
+#      switch (region)
+    mov     %eax,%ecx
+    and     $1,%eax
+    jz      .Lregion02
+# region 1 or 3
+    movsd   %xmm0,%xmm2                               # swap sin,cos
+    movsd   %xmm1,%xmm0                               # sin = cos
+    xorpd   %xmm1,%xmm1
+    subsd   %xmm2,%xmm1                               # cos = -sin
+   
+.Lregion02:
+    and     $2,%ecx
+    jz      .Lregion23
+# region 2 or 3
+    movsd   %xmm0,%xmm2
+    movsd   %xmm1,%xmm3
+    xorpd   %xmm0,%xmm0
+    xorpd   %xmm1,%xmm1
+    subsd   %xmm2,%xmm0                               # sin = -sin
+    subsd   %xmm3,%xmm1                               # cos = -cos
+  
+.Lregion23:        
+##  if (xneg) *s = -*s ;
+    cmp     %r10,%rdx
+    jz      .L__sc_cleanup
+    movsd   %xmm0,%xmm2
+    xorpd   %xmm0,%xmm0
+    subsd   %xmm2,%xmm0                               # sin = -sin
+
+.align 16
+.L__sc_cleanup:
+    cvtsd2ss %xmm0,%xmm0                              # convert back to floats
+    cvtsd2ss %xmm1,%xmm1
+
+    movss   %xmm0,(%rdi)                              # save the sin
+    movss   %xmm1,(%rsi)                              # save the cos
+    
+    add     $stack_size,%rsp
+    ret
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lsincosf_reduce_precise:
+#      /* Reduce abs(x) into range [-pi/4,pi/4] */
+#      __amd_remainder_piby2(ax, &r, &region);
+
+    mov     %rdx,p_temp(%rsp)                         # save ux for use later
+    mov     %r10,p_temp1(%rsp)                        # save ax for use later
+    mov     %rdi,p_temp2(%rsp)                        # save ux for use later
+    mov     %rsi,p_temp3(%rsp)                        # save ax for use later
+    movd    %xmm0,%rdi
+    lea     r(%rsp),%rsi
+    lea     region(%rsp),%rdx
+    sub     $0x040,%rsp    
+
+    call    __amd_remainder_piby2d2f@PLT
+
+    add     $0x040,%rsp
+    mov     p_temp(%rsp),%rdx                         # restore ux for use later
+    mov     p_temp1(%rsp),%r10                        # restore ax for use later    
+    mov     p_temp2(%rsp),%rdi                        # restore ux for use later
+    mov     p_temp3(%rsp),%rsi                        # restore ax for use later    
+
+    mov     $1,%r8d                                   # for determining region later on
+    movsd   r(%rsp),%xmm0                             # r
+    mov     region(%rsp),%eax                         # region
+    jmp     .L__sc_piby4
+ 
+.align 16    
+.L__sc_naninf:
+    cvtsd2ss %xmm0,%xmm0                              # convert back to floats
+    call    fname_special							  # rdi and rsi are ready for the function call
+    add     $stack_size, %rsp
+    ret
diff --git a/src/gas/sinf.S b/src/gas/sinf.S
new file mode 100644
index 0000000..c2083ff
--- /dev/null
+++ b/src/gas/sinf.S
@@ -0,0 +1,436 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+#
+# An implementation of the sinf function.
+#
+# Prototype:
+#
+#     double sinf(double x);
+#
+#   Computes sinf(x).
+#   It will provide proper C99 return values,
+#   but may not raise floating point status bits properly.
+#   Based on the NAG C implementation.
+#
+#
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.data
+.align 32
+.L__real_3ff0000000000000: .quad 0x03ff0000000000000  # 1.0
+                  .quad 0                             # for alignment
+.L__real_3fe0000000000000: .quad 0x03fe0000000000000  # 0.5
+                  .quad 0
+.L__real_3fc5555555555555: .quad 0x03fc5555555555555  # 0.166666666666
+                  .quad 0
+.L__real_3fe45f306dc9c883: .quad 0x03fe45f306dc9c883  # twobypi
+                  .quad 0
+.L__real_3ff921fb54400000: .quad 0x03ff921fb54400000  # piby2_1
+                  .quad 0
+.L__real_3dd0b4611a626331: .quad 0x03dd0b4611a626331  # piby2_1tail
+                  .quad 0
+.L__real_3dd0b4611a600000: .quad 0x03dd0b4611a600000  # piby2_2
+                  .quad 0
+.L__real_3ba3198a2e037073: .quad 0x03ba3198a2e037073  # piby2_2tail
+                  .quad 0               
+.L__real_411E848000000000: .quad 0x415312d000000000   # 5e6 0x0411E848000000000  # 5e5
+                  .quad 0
+
+.align 32
+.Lcosfarray:
+   .quad   0x0bfe0000000000000                        # -0.5            c0
+   .quad   0
+   .quad   0x03fa5555555555555                        # 0.0416667       c1
+   .quad   0
+   .quad   0x0bf56c16c16c16c16                        # -0.00138889     c2
+   .quad   0
+   .quad   0x03EFA01A01A01A019                        # 2.48016e-005    c3
+   .quad   0
+   .quad   0x0be927e4fb7789f5c                        # -2.75573e-007   c4
+   .quad   0
+
+.align 32   
+.Lsinfarray:
+   .quad   0x0bfc5555555555555                        # -0.166667       s1
+   .quad   0
+   .quad   0x03f81111111111111                        # 0.00833333      s2
+   .quad   0
+   .quad   0x0bf2a01a01a01a01a                        # -0.000198413    s3
+   .quad   0
+   .quad   0x03ec71de3a556c734                        # 2.75573e-006    s4
+   .quad   0
+
+.text
+.align 32
+.p2align 4,,15
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(sinf)
+#define fname_special _sinf_special@PLT
+
+# define local variable storage offsets
+.equ   p_temp,     0x30                               # temporary for get/put bits operation
+.equ   p_temp1,    0x40                               # temporary for get/put bits operation
+.equ   r,          0x50                               # pointer to r for amd_remainder_piby2
+.equ   region,     0x60                               # pointer to region for amd_remainder_piby2
+.equ   stack_size, 0x88
+
+.globl fname
+.type  fname,@function
+
+fname:
+   sub      $stack_size, %rsp
+   xorpd    %xmm2, %xmm2                              # zeroed out for later use
+
+##  if NaN or inf
+   movd     %xmm0, %edx
+   mov      $0x07f800000, %eax
+   mov      %eax, %r10d
+   and      %edx, %r10d
+   cmp      %eax, %r10d
+   jz       .Lsinf_naninf
+
+# GET_BITS_DP64(x, ux);
+# get the input value to an integer register.
+   cvtss2sd %xmm0, %xmm0         # convert input to double.
+   movsd    %xmm0,p_temp(%rsp)   # get the input value to an integer register.      
+      
+   mov   p_temp(%rsp), %rdx      # rdx is ux
+
+#  ax = (ux & ~SIGNBIT_DP64);
+   mov      $0x07fffffffffffffff, %r10
+   and      %rdx, %r10            # r10 is ax
+   mov      $1, %r8d            # for determining region later on
+
+##  if (ax <= 0x3fe921fb54442d18) /* abs(x) <= pi/4 */
+   mov      $0x03fe921fb54442d18, %rax
+   cmp      %rax, %r10
+   jg       .Lsinf_reduce
+
+##      if (ax < 0x3f80000000000000) /* abs(x) < 2.0^(-7) */
+   mov      $0x3f80000000000000, %rax
+   cmp      %rax, %r10
+   jge      .Lsinf_small
+
+##          if (ax < 0x3f20000000000000) /* abs(x) < 2.0^(-13) */
+   mov      $0x3f20000000000000, %rax
+   cmp      %rax, %r10
+   jge      .Lsinf_smaller
+
+#                  sinf = x;
+   jmp      .Lsinf_cleanup         # done
+
+##          else
+
+.Lsinf_smaller:
+#              sinf = x - x^3 * 0.1666666666666666666;
+   movsd    %xmm0, %xmm2
+   movsd    .L__real_3fc5555555555555(%rip), %xmm4   # 0.1666666666666666666
+   mulsd    %xmm2, %xmm2            # x^2
+   mulsd    %xmm0, %xmm2            # x^3
+   mulsd    %xmm4, %xmm2            # x^3 * 0.1666666666666666666
+   subsd    %xmm2, %xmm0            # x - x^3 * 0.1666666666666666666
+   jmp      .Lsinf_cleanup          
+
+.Lsinf_small:
+   movsd    %xmm0, %xmm2
+   mulsd    %xmm0, %xmm2            # x2
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# region 0 or 2    - do a sinf calculation
+#  zs = x + x3((s1 + x2 * s2) + x4(s3 + x2 * s4));
+   movsd    .Lsinfarray+0x30(%rip), %xmm1   # s4
+   mulsd    %xmm2, %xmm1                 # s4x2
+   movsd    %xmm2, %xmm4                    # move for x4
+   movsd    .Lsinfarray+0x10(%rip), %xmm5   # s2
+   mulsd    %xmm2, %xmm4                 # x4
+   movsd    %xmm0, %xmm3                     # move for x3
+   mulsd    %xmm2, %xmm5                     # s2x2
+   mulsd    %xmm2, %xmm3                     # x3      
+   addsd    .Lsinfarray+0x20(%rip), %xmm1   # s3+s4x2
+   mulsd    %xmm4, %xmm1                    # s3x4+s4x6
+   addsd    .Lsinfarray(%rip), %xmm5           # s1+s2x2
+   addsd    %xmm5, %xmm1                    # s1+s2x2+s3x4+s4x6
+   mulsd    %xmm3, %xmm1                    # x3(s1+s2x2+s3x4+s4x6)
+   addsd    %xmm1, %xmm0                    # x + x3(s1+s2x2+s3x4+s4x6)
+   jmp      .Lsinf_cleanup
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 32
+.Lsinf_reduce:
+
+#  xneg = (ax != ux);
+   cmp      %r10, %rdx
+   mov      $0, %r11d
+
+##  if (xneg) x = -x;
+   jz       .L50e5
+   mov      $1, %r11d
+   subsd    %xmm0, %xmm2
+   movsd    %xmm2, %xmm0
+
+.L50e5:
+##  if (x < 5.0e5)
+   cmp      .L__real_411E848000000000(%rip), %r10
+   jae      .Lsinf_reduce_precise
+
+# reduce  the argument to be in a range from -pi/4 to +pi/4
+# by subtracting multiples of pi/2
+   movsd    %xmm0, %xmm2
+   movsd    .L__real_3fe45f306dc9c883(%rip), %xmm3            # twobypi
+   movsd    %xmm0, %xmm4
+   movsd    .L__real_3fe0000000000000(%rip), %xmm5            # .5
+   mulsd    %xmm3, %xmm2
+
+#/* How many pi/2 is x a multiple of? */
+#      xexp  = ax >> EXPSHIFTBITS_DP64;
+   mov      %r10, %r9
+   shr      $52, %r9                  #>>EXPSHIFTBITS_DP64
+
+#        npi2  = (int)(x * twobypi + 0.5);
+   addsd    %xmm5, %xmm2                  # npi2
+
+   movsd    .L__real_3ff921fb54400000(%rip), %xmm3         # piby2_1
+   cvttpd2dq   %xmm2, %xmm0               # convert to integer
+   movsd    .L__real_3dd0b4611a626331(%rip), %xmm1         # piby2_1tail
+   cvtdq2pd   %xmm0, %xmm2               # and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+#      rhead  = x - npi2 * piby2_1;
+   mulsd    %xmm2, %xmm3
+   subsd    %xmm3, %xmm4                  # rhead
+
+#      rtail  = npi2 * piby2_1tail;
+   mulsd    %xmm2, %xmm1
+   movd     %xmm0, %eax
+
+#      GET_BITS_DP64(rhead-rtail, uy);               ; originally only rhead
+   movsd    %xmm4, %xmm0
+   subsd    %xmm1, %xmm0
+
+   movsd    .L__real_3dd0b4611a600000(%rip), %xmm3      # piby2_2
+   movsd    %xmm0,p_temp(%rsp)
+   movsd    .L__real_3ba3198a2e037073(%rip), %xmm5      # piby2_2tail
+   mov      p_temp(%rsp), %rcx         # rcx is rhead-rtail
+
+#   xmm0=r, xmm4=rhead, xmm1=rtail, xmm2=npi2, xmm3=temp for calc, xmm5= temp for calc
+#      expdiff = xexp - ((uy & EXPBITS_DP64) >> EXPSHIFTBITS_DP64);
+   shl      $1, %rcx               # strip any sign bit
+   shr      $53, %rcx               #>> EXPSHIFTBITS_DP64 +1
+   sub      %rcx, %r9               #expdiff
+
+##      if (expdiff > 15)
+   cmp      $15, %r9
+   jle      .Lexpdiff15
+
+#          /* The remainder is pretty small compared with x, which
+#             implies that x is a near multiple of pi/2
+#             (x matches the multiple to at least 15 bits) */
+
+#          t  = rhead;
+   movsd    %xmm4, %xmm1
+
+#          rtail  = npi2 * piby2_2;
+   mulsd    %xmm2, %xmm3
+
+#          rhead  = t - rtail;
+   mulsd    %xmm2, %xmm5            # npi2 * piby2_2tail
+   subsd    %xmm3, %xmm4            # rhead
+
+#          rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+   subsd    %xmm4, %xmm1            # t - rhead
+   subsd    %xmm3, %xmm1            # -rtail
+   subsd    %xmm1, %xmm5            #rtail
+
+#      r = rhead - rtail;
+   movsd    %xmm4, %xmm0
+
+#HARSHA
+#xmm1=rtail
+   movsd    %xmm5, %xmm1
+   subsd    %xmm5, %xmm0
+
+#   xmm0=r, xmm4=rhead, xmm1=rtail
+.Lexpdiff15:
+#      region = npi2 & 3;
+# No need rr for float case
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+## if the input was close to a pi/2 multiple
+# The original NAG code missed this trick.  If the input is very close to n*pi/2 after
+# reduction,
+# then the sinf is ~ 1.0 , to within 15 bits, when r is < 2^-13.  We already
+# have x at this point, so we can skip the sinf polynomials.
+
+   cmp      $0x03f2, %rcx            ## if r  small.
+   jge      .Lsinf_piby4            # use taylor series if not
+   cmp      $0x03de, %rcx            ## if r really small.
+   jle      .Lr_small               # then sinf(r) = 0
+
+   movsd    %xmm0, %xmm2
+   mulsd    %xmm2, %xmm2            #x^2
+
+##      if region is 0 or 2 do a sinf calc.
+   and      %eax, %r8d
+   jnz      .Lcosfregion
+
+# region 0 or 2 do a sinf calculation
+# use simply polynomial
+#              x - x*x*x*0.166666666666666666;
+   movsd    .L__real_3fc5555555555555(%rip), %xmm3         #
+   mulsd    %xmm0, %xmm3                   # * x
+   mulsd    %xmm2, %xmm3                  # * x^2
+   subsd    %xmm3, %xmm0                   # xs
+   jmp      .Ladjust_region
+
+.align 32
+.Lcosfregion:
+# region 1 or 3 do a cosf calculation
+# use simply polynomial
+#              1.0 - x*x*0.5;
+   movsd    .L__real_3ff0000000000000(%rip), %xmm0         # 1.0
+   mulsd    .L__real_3fe0000000000000(%rip), %xmm2         # 0.5 *x^2
+   subsd    %xmm2, %xmm0                  # xc
+   jmp      .Ladjust_region
+
+.align 32
+.Lr_small:
+##      if region is 1 or 3   do a cosf calc.
+   and      %eax, %r8d
+   jz       .Ladjust_region
+
+# odd
+   movsd    .L__real_3ff0000000000000(%rip), %xmm0         # cosf(r) is a 1
+   jmp      .Ladjust_region
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lsinf_reduce_precise:
+#      // Reduce x into range [-pi/4,pi/4]
+#      __amd_remainder_piby2d2f(x, &r, &region);
+
+   mov      %r11,p_temp(%rsp)
+   lea      region(%rsp), %rdx
+   lea      r(%rsp), %rsi
+   movd     %xmm0, %rdi
+   sub      $0x20, %rsp
+   
+   call     __amd_remainder_piby2d2f@PLT
+
+   add      $0x20, %rsp
+   mov      p_temp(%rsp), %r11
+   mov      $1, %r8d            # for determining region later on
+   movsd    r(%rsp), %xmm1      #//x
+   mov      region(%rsp), %eax   #//region
+
+# xmm0 = x, xmm4 = xx, r8d = 1, eax= region
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# perform taylor series to calc sinfx, cosfx
+.Lsinf_piby4:
+#  x2 = r * r;
+   movsd    %xmm0, %xmm2
+   mulsd    %xmm0, %xmm2                  #x2
+
+##      if region is 0 or 2   do a sinf calc.
+   and      %eax, %r8d
+   jnz      .Lcosfregion2
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# region 0 or 2 do a sinf calculation
+#  zs = x + x3((s1 + x2 * s2) + x4(s3 + x2 * s4));
+   movsd    .Lsinfarray+0x30(%rip), %xmm1   # s4
+   mulsd    %xmm2, %xmm1                 # s4x2
+   movsd    %xmm2, %xmm4                    # move for x4   
+   mulsd    %xmm2, %xmm4                 # x4
+   movsd    .Lsinfarray+0x10(%rip), %xmm5   # s2
+   mulsd    %xmm2, %xmm5                     # s2x2
+   movsd    %xmm0, %xmm3                     # move for x3
+   mulsd    %xmm2, %xmm3                     # x3      
+   addsd    .Lsinfarray+0x20(%rip), %xmm1   # s3+s4x2
+   mulsd    %xmm4, %xmm1                    # s3x4+s4x6
+   addsd    .Lsinfarray(%rip), %xmm5           # s1+s2x2
+   addsd    %xmm5, %xmm1                    # s1+s2x2+s3x4+s4x6
+   mulsd    %xmm3, %xmm1                    # x3(s1+s2x2+s3x4+s4x6)
+   addsd    %xmm1, %xmm0                    # x + x3(s1+s2x2+s3x4+s4x6)
+      
+   jmp      .Ladjust_region
+
+.align 32
+.Lcosfregion2:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# region 1 or 3    - do a cosf calculation
+#    zc = 1-0.5*x2+ c1*x4 +c2*x6 +c3*x8 + c4*x10 for a higher precision
+   movsd    .Lcosfarray+0x40(%rip), %xmm1    # c4
+   movsd    %xmm2, %xmm4                     # move for x4
+   mulsd    %xmm2, %xmm1                     # c4x2
+   movsd    .Lcosfarray+0x20(%rip), %xmm3    # c2
+   mulsd    %xmm2, %xmm4                     # x4
+   movsd    .Lcosfarray(%rip), %xmm0         # c0
+   mulsd    %xmm2, %xmm3                     # c2x2
+   mulsd    %xmm2, %xmm0                     # c0x2 (=-0.5x2)
+   addsd    .Lcosfarray+0x30(%rip), %xmm1      # c3+c4x2
+   mulsd    %xmm4, %xmm1                     # c3x4 + c4x6
+   addsd    .Lcosfarray+0x10(%rip), %xmm3      # c1+c2x2
+   addsd    %xmm3, %xmm1                     # c1 + c2x2 + c3x4 + c4x6
+   mulsd    %xmm4, %xmm1                  # c1x4 + c2x6 + c3x8 + c4x10
+   addsd    .L__real_3ff0000000000000(%rip), %xmm0 # 1 - 0.5x2
+   addsd    %xmm1, %xmm0                     # 1 - 0.5x2 + c1x4 + c2x6 + c3x8 + c4x10
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+.align 32
+.Ladjust_region:      # positive or negative
+#      switch (region)
+   shr      $1, %eax
+   mov      %eax, %ecx
+   and      %r11d, %eax
+
+   not      %ecx
+   not      %r11d
+   and      %r11d, %ecx
+
+   or       %ecx, %eax
+   and      $1, %eax
+   jnz      .Lsinf_cleanup
+
+## if the original region 0, 1 and arg is negative, then we negate the result.
+## if the original region 2, 3 and arg is positive, then we negate the result.
+   movsd    %xmm0, %xmm2
+   xorpd    %xmm0, %xmm0
+   subsd    %xmm2, %xmm0
+
+.align 32
+.Lsinf_cleanup:
+   cvtsd2ss %xmm0, %xmm0
+   add      $stack_size, %rsp
+   ret
+
+.align 32
+.Lsinf_naninf:
+   call     fname_special
+   add      $stack_size, %rsp
+   ret
+
+
diff --git a/src/gas/trunc.S b/src/gas/trunc.S
new file mode 100644
index 0000000..c29d0fd
--- /dev/null
+++ b/src/gas/trunc.S
@@ -0,0 +1,87 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+# trunc.S
+#
+# An implementation of the trunc libm function.
+#
+# The trunc functions round their argument to the integer value, in floating format,
+# nearest to but no larger in magnitude than the argument.
+#
+#
+# Prototype:
+#
+#     double trunc(double x);
+#
+
+#
+#   Algorithm:
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(trunc)
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+
+	MOVAPD %xmm0,%xmm1	
+
+#convert double to integer.	
+	CVTTSD2SIQ %xmm0,%rax
+	CMP .L__Erro_mask(%rip),%rax
+	jz .Error_val	
+#convert integer to double	
+	CVTSI2SDQ %rax,%xmm0
+	
+	PSRLQ $63,%xmm1
+	PSLLQ $63,%xmm1
+	
+	POR %xmm1,%xmm0
+	
+	
+	ret
+	
+.Error_val:
+	MOVAPD %xmm1,%xmm2
+	CMPEQSD	%xmm1,%xmm1			
+	ADDSD %xmm2,%xmm2	
+	
+	PAND %xmm1,%xmm0
+	PANDN %xmm2,%xmm1
+	POR %xmm1,%xmm0
+	
+		
+    ret
+
+.data
+.align 16
+.L__Erro_mask:  		.quad 0x8000000000000000
+			        .quad 0x0
diff --git a/src/gas/truncf.S b/src/gas/truncf.S
new file mode 100644
index 0000000..c73ad8f
--- /dev/null
+++ b/src/gas/truncf.S
@@ -0,0 +1,93 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+# truncf.S
+#
+# An implementation of the truncf libm function.
+#
+#
+# The trunf functions round their argument to the integer value, in floating format,
+# nearest to but no larger in magnitude than the argument.
+#
+#
+# Prototype:
+#
+#     float truncf(float x);
+#
+
+#
+#   Algorithm:
+#
+
+#include "fn_macros.h"
+#define fname FN_PROTOTYPE(truncf )
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.text
+.align 16
+.p2align 4,,15
+.globl fname
+.type fname,@function
+fname:
+	
+	
+	MOVAPD %xmm0,%xmm1	
+
+# convert  float to integer.
+	CVTTSS2SIQ %xmm0,%rax
+	
+	CMP .L__Erro_mask(%rip),%rax
+	jz .Error_val	
+	
+# convert  integer	to float
+	CVTSI2SSQ %rax,%xmm0
+	
+	PSRLD $31,%xmm1
+	PSLLD $31,%xmm1
+	
+	POR %xmm1,%xmm0
+	
+	
+	ret
+	
+.Error_val:
+	MOVAPD %xmm1,%xmm2
+	CMPEQSS	%xmm1,%xmm1			
+	ADDSS %xmm2,%xmm2	
+	
+	PAND %xmm1,%xmm0
+	PANDN %xmm2,%xmm1
+	POR %xmm1,%xmm0
+	
+	
+
+	
+    ret
+
+.data
+.align 16
+.L__Erro_mask:  		.quad 0x8000000000000000
+					    .quad 0x0
diff --git a/src/gas/v4hcosl.S b/src/gas/v4hcosl.S
new file mode 100644
index 0000000..a3ded17
--- /dev/null
+++ b/src/gas/v4hcosl.S
@@ -0,0 +1,62 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+# v4hcosl.s
+#
+# Helper routines for testing the x4 double and x8 single vector
+# math functions.
+#
+# Prototype:
+#
+#     void v4cos(__m128d x1, __m128d x2, double * ya);
+#
+#   Computes 4 cos values simultaneously and returns them
+#   in the v4a array.
+#   Assumes that ya is 16 byte aligned.
+#
+#
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+# xmm0 - __m128d x1
+# xmm1 - __m128d x2
+# rdi   - double *ya
+
+.extern __vrd4_cos
+    .text
+    .align 16
+    .p2align 4,,15
+.globl v4cos
+    .type   v4cos,@function
+v4cos:
+        push    %rdi
+        call    __vrd4_cos@PLT
+        pop             %rdi
+        movdqa  %xmm0,(%rdi)
+        movdqa  %xmm1,16(%rdi)
+	ret
diff --git a/src/gas/v4helpl.S b/src/gas/v4helpl.S
new file mode 100644
index 0000000..02fa080
--- /dev/null
+++ b/src/gas/v4helpl.S
@@ -0,0 +1,83 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+# v4help.s
+#
+# Helper routines for testing the x4 double and x8 single vector
+# math functions.
+#
+# Prototype:
+#
+#     void v4exp(__m128d x1, __m128d x2, double * ya);
+#
+#   Computes 4 exp values simultaneously and returns them
+#   in the v4a array.
+#   Assumes that ya is 16 byte aligned.
+#
+#
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+
+# %xmm0 - __m128d x1
+# %xmm1 - __m128d x2
+# rdi   - double *ya
+
+.extern	__vrd4_exp
+    .text
+    .align 16
+    .p2align 4,,15
+.globl v4exp
+    .type   v4exp,@function
+v4exp:
+	push	%rdi
+	call	__vrd4_exp@PLT
+	pop		%rdi
+	movdqa	%xmm0,(%rdi)
+	movdqa	%xmm1,16(%rdi)
+	ret
+
+
+# %xmm0,%rcx - __m128d x1
+# %xmm1,%rdx - __m128d x2
+# r8   - double *ya
+
+.extern	__vrs8_expf
+    .text
+    .align 16
+    .p2align 4,,15
+.globl v8expf
+    .type   v8expf,@function
+v8expf:
+	push	%rdi
+	call	__vrs8_expf@PLT
+	pop		%rdi
+	movdqa	%xmm0,(%rdi)
+	movdqa	%xmm1,16(%rdi)
+	ret
+
diff --git a/src/gas/v4hfrcpal.S b/src/gas/v4hfrcpal.S
new file mode 100644
index 0000000..d648d9d
--- /dev/null
+++ b/src/gas/v4hfrcpal.S
@@ -0,0 +1,63 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+# v4hfrcpal.s
+#
+# Helper routines for testing the x4 double and x8 single vector
+# math functions.
+#
+# Prototype:
+#
+#     void v4frcpa(__m128d x1, __m128d x2, double * ya);
+#
+#   Computes 4 frcpa values simultaneously and returns them
+#   in the v4a array.
+#   Assumes that ya is 16 byte aligned.
+#
+#
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+# xmm0 - __m128d x1
+# xmm1 - __m128d x2
+# rdi   - double *ya
+
+.extern __vrd4_frcpa
+    .text
+    .align 16
+    .p2align 4,,15
+.globl v4frcpa
+    .type   v4frcpa,@function
+v4frcpa:
+        push    %rdi
+        call    __vrd4_frcpa@PLT
+        pop             %rdi
+        movdqa  %xmm0,(%rdi)
+        movdqa  %xmm1,16(%rdi)
+	ret
+
diff --git a/src/gas/v4hlog10l.S b/src/gas/v4hlog10l.S
new file mode 100644
index 0000000..0cdb6ba
--- /dev/null
+++ b/src/gas/v4hlog10l.S
@@ -0,0 +1,81 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+# v4hlog10l.s
+#
+# Helper routines for testing the x4 double and x8 single vector
+# math functions.
+#
+# Prototype:
+#
+#     void v4log10(__m128d x1, __m128d x2, double * ya);
+#
+#   Computes 4 log10 values simultaneously and returns them
+#   in the v4a array.
+#   Assumes that ya is 16 byte aligned.
+#
+#
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+# xmm0 - __m128d x1
+# xmm1 - __m128d x2
+# rdi   - double *ya
+
+.extern __vrd4_log10
+    .text
+    .align 16
+    .p2align 4,,15
+.globl v4log10
+    .type   v4log10,@function
+v4log10:
+        push    %rdi
+        call    __vrd4_log10@PLT
+        pop             %rdi
+        movdqa  %xmm0,(%rdi)
+        movdqa  %xmm1,16(%rdi)
+	ret
+
+# xmm0 - __m128 x1
+# xmm1 - __m128 x2
+# rdi   - single *ya
+
+.extern __vrs8_log10f
+    .text
+    .align 16
+    .p2align 4,,15
+.globl v8log10f
+    .type   v8log10f,@function
+v8log10f:
+        push    %rdi
+        call    __vrs8_log10f@PLT
+        pop             %rdi
+        movdqa  %xmm0,(%rdi)
+        movdqa  %xmm1,16(%rdi)
+
+	ret
diff --git a/src/gas/v4hlog2l.S b/src/gas/v4hlog2l.S
new file mode 100644
index 0000000..1a8c33e
--- /dev/null
+++ b/src/gas/v4hlog2l.S
@@ -0,0 +1,81 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+# v4hlog10l.s
+#
+# Helper routines for testing the x4 double and x8 single vector
+# math functions.
+#
+# Prototype:
+#
+#     void v4log2(__m128d x1, __m128d x2, double * ya);
+#
+#   Computes 4 log2 values simultaneously and returns them
+#   in the v4a array.
+#   Assumes that ya is 16 byte aligned.
+#
+#
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+# xmm0 - __m128d x1
+# xmm1 - __m128d x2
+# rdi   - double *ya
+
+.extern __vrd4_log2
+    .text
+    .align 16
+    .p2align 4,,15
+.globl v4log2
+    .type   v4log2,@function
+v4log2:
+        push    %rdi
+        call    __vrd4_log2@PLT
+        pop             %rdi
+        movdqa  %xmm0,(%rdi)
+        movdqa  %xmm1,16(%rdi)
+	ret
+
+# xmm0 - __m128 x1
+# xmm1 - __m128 x2
+# rdi   - single *ya
+
+.extern __vrs8_log2f
+    .text
+    .align 16
+    .p2align 4,,15
+.globl v8log2f
+    .type   v8log2f,@function
+v8log2f:
+        push    %rdi
+        call    __vrs8_log2f@PLT
+        pop             %rdi
+        movdqa  %xmm0,(%rdi)
+        movdqa  %xmm1,16(%rdi)
+
+	ret
diff --git a/src/gas/v4hlogl.S b/src/gas/v4hlogl.S
new file mode 100644
index 0000000..512648d
--- /dev/null
+++ b/src/gas/v4hlogl.S
@@ -0,0 +1,84 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+# v4hlog.asm
+#
+# Helper routines for testing the x4 double and x8 single vector
+# math functions.
+#
+# Prototype:
+#
+#     void v4log(__m128d x1, __m128d x2, double * ya);
+#
+#   Computes 4 log values simultaneously and returns them
+#   in the v4a array.
+#   Assumes that ya is 16 byte aligned.
+#
+#
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+
+# xmm0 - __m128d x1
+# xmm1 - __m128d x2
+# rdi   - double *ya
+
+.extern __vrd4_log
+    .text
+    .align 16
+    .p2align 4,,15
+.globl v4log
+    .type   v4log,@function
+v4log:
+        push    %rdi
+        call    __vrd4_log@PLT
+        pop             %rdi
+        movdqa  %xmm0,(%rdi)
+        movdqa  %xmm1,16(%rdi)
+	ret
+
+
+# xmm0 - __m128 x1
+# xmm1 - __m128 x2
+# rdi   - double *ya
+
+#.extern __vrs8_logf
+    .text
+    .align 16
+    .p2align 4,,15
+.globl v8logf
+    .type   v8logf,@function
+v8logf:
+        push    %rdi
+        call    __vrs8_logf@PLT
+        pop             %rdi
+        movdqa  %xmm0,(%rdi)
+        movdqa  %xmm1,16(%rdi)
+
+	ret
+
diff --git a/src/gas/v4hsinl.S b/src/gas/v4hsinl.S
new file mode 100644
index 0000000..97bfa2d
--- /dev/null
+++ b/src/gas/v4hsinl.S
@@ -0,0 +1,62 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+# v4hsinl.s
+#
+# Helper routines for testing the x4 double and x8 single vector
+# math functions.
+#
+# Prototype:
+#
+#     void v4sin(__m128d x1, __m128d x2, double * ya);
+#
+#   Computes 4 sin values simultaneously and returns them
+#   in the v4a array.
+#   Assumes that ya is 16 byte aligned.
+#
+#
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+# xmm0 - __m128d x1
+# xmm1 - __m128d x2
+# rdi   - double *ya
+
+.extern __vrd4_sin
+    .text
+    .align 16
+    .p2align 4,,15
+.globl v4sin
+    .type   v4sin,@function
+v4sin:
+        push    %rdi
+        call    __vrd4_sin@PLT
+        pop             %rdi
+        movdqa  %xmm0,(%rdi)
+        movdqa  %xmm1,16(%rdi)
+	ret
diff --git a/src/gas/vrd2cos.S b/src/gas/vrd2cos.S
new file mode 100644
index 0000000..d12a156
--- /dev/null
+++ b/src/gas/vrd2cos.S
@@ -0,0 +1,756 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# A vector implementation of the libm cos function.
+#
+# Prototype:
+#
+#     __m128d __vrd2_cos(__m128d x);
+#
+#   Computes Cosine of x
+#   It will provide proper C99 return values,
+#   but may not raise floating point status bits properly.
+#   Based on the NAG C implementation.
+#   Author: Harsha Jagasia
+#   Email:  harsha.jagasia@amd.com
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.data
+.align 16
+.L__real_7fffffffffffffff: .quad 0x07fffffffffffffff	#Sign bit zero
+			.quad 0x07fffffffffffffff
+.L__real_3ff0000000000000: .quad 0x03ff0000000000000	# 1.0
+			.quad 0x03ff0000000000000
+.L__real_v2p__27:		.quad 0x03e40000000000000	# 2p-27
+			.quad 0x03e40000000000000
+.L__real_3fe0000000000000: .quad 0x03fe0000000000000	# 0.5
+			.quad 0x03fe0000000000000
+.L__real_3fc5555555555555: .quad 0x03fc5555555555555	# 0.166666666666
+			.quad 0x03fc5555555555555
+.L__real_3fe45f306dc9c883: .quad 0x03fe45f306dc9c883	# twobypi
+			.quad 0x03fe45f306dc9c883
+.L__real_3ff921fb54400000: .quad 0x03ff921fb54400000	# piby2_1
+			.quad 0x03ff921fb54400000
+.L__real_3dd0b4611a626331: .quad 0x03dd0b4611a626331	# piby2_1tail
+			.quad 0x03dd0b4611a626331
+.L__real_3dd0b4611a600000: .quad 0x03dd0b4611a600000	# piby2_2
+			.quad 0x03dd0b4611a600000
+.L__real_3ba3198a2e037073: .quad 0x03ba3198a2e037073	# piby2_2tail
+			.quad 0x03ba3198a2e037073
+.L__real_fffffffff8000000: .quad 0x0fffffffff8000000	# mask for stripping head and tail
+			.quad 0x0fffffffff8000000
+.L__real_8000000000000000:	.quad 0x08000000000000000	# -0  or signbit
+			.quad 0x08000000000000000
+.L__reald_one_one:		.quad 0x00000000100000001	#
+			.quad 0
+.L__reald_two_two:		.quad 0x00000000200000002	#
+			.quad 0
+.L__reald_one_zero:	.quad 0x00000000100000000	# sin_cos_filter
+			.quad 0
+.L__reald_zero_one:	.quad 0x00000000000000001	#
+			.quad 0
+.L__reald_two_zero:	.quad 0x00000000200000000	#
+			.quad 0
+.L__realq_one_one:		.quad 0x00000000000000001	#
+			.quad 0x00000000000000001	#
+.L__realq_two_two:		.quad 0x00000000000000002	#
+			.quad 0x00000000000000002	#
+.L__real_1_x_mask:		.quad 0x0ffffffffffffffff	#
+			.quad 0x03ff0000000000000	#
+.L__real_zero:		.quad 0x00000000000000000	#
+			.quad 0x00000000000000000	#
+.L__real_one:		.quad 0x00000000000000001	#
+			.quad 0x00000000000000001	#
+
+.Lcosarray:
+	.quad	0x03fa5555555555555		#  0.0416667		   	c1
+	.quad	0x03fa5555555555555
+	.quad	0x0bf56c16c16c16967		# -0.00138889	   		c2
+	.quad	0x0bf56c16c16c16967
+	.quad	0x03efa01a019f4ec90		#  2.48016e-005			c3
+	.quad	0x03efa01a019f4ec90
+	.quad	0x0be927e4fa17f65f6		# -2.75573e-007			c4
+	.quad	0x0be927e4fa17f65f6
+	.quad	0x03e21eeb69037ab78		#  2.08761e-009			c5
+	.quad	0x03e21eeb69037ab78
+	.quad	0x0bda907db46cc5e42		# -1.13826e-011	   		c6
+	.quad	0x0bda907db46cc5e42
+.Lsinarray:
+	.quad	0x0bfc5555555555555		# -0.166667	   		s1
+	.quad	0x0bfc5555555555555
+	.quad	0x03f81111111110bb3		#  0.00833333	   		s2
+	.quad	0x03f81111111110bb3
+	.quad	0x0bf2a01a019e83e5c		# -0.000198413			s3
+	.quad	0x0bf2a01a019e83e5c
+	.quad	0x03ec71de3796cde01		#  2.75573e-006			s4
+	.quad	0x03ec71de3796cde01
+	.quad	0x0be5ae600b42fdfa7		# -2.50511e-008			s5
+	.quad	0x0be5ae600b42fdfa7
+	.quad	0x03de5e0b2f9a43bb8		#  1.59181e-010	   		s6
+	.quad	0x03de5e0b2f9a43bb8
+.Lsincosarray:
+	.quad	0x0bfc5555555555555		# -0.166667	   		s1
+	.quad	0x03fa5555555555555		#  0.0416667		   	c1
+	.quad	0x03f81111111110bb3		#  0.00833333	   		s2
+	.quad	0x0bf56c16c16c16967		#				c2
+	.quad	0x0bf2a01a019e83e5c		# -0.000198413			s3
+	.quad	0x03efa01a019f4ec90
+	.quad	0x03ec71de3796cde01		#  2.75573e-006			s4
+	.quad	0x0be927e4fa17f65f6
+	.quad	0x0be5ae600b42fdfa7		# -2.50511e-008			s5
+	.quad	0x03e21eeb69037ab78
+	.quad	0x03de5e0b2f9a43bb8		#  1.59181e-010	   		s6
+	.quad	0x0bda907db46cc5e42
+.Lcossinarray:
+	.quad	0x03fa5555555555555		#  0.0416667		   	c1
+	.quad	0x0bfc5555555555555		# -0.166667	   		s1
+	.quad	0x0bf56c16c16c16967		#				c2
+	.quad	0x03f81111111110bb3		#  0.00833333	   		s2
+	.quad	0x03efa01a019f4ec90
+	.quad	0x0bf2a01a019e83e5c		# -0.000198413			s3
+	.quad	0x0be927e4fa17f65f6
+	.quad	0x03ec71de3796cde01		#  2.75573e-006			s4
+	.quad	0x03e21eeb69037ab78
+	.quad	0x0be5ae600b42fdfa7		# -2.50511e-008			s5
+	.quad	0x0bda907db46cc5e42
+	.quad	0x03de5e0b2f9a43bb8		#  1.59181e-010	   		s6
+
+.text
+.align 16
+.p2align 4,,15
+
+.equ	p_temp,	0x00		# temporary for get/put bits operation
+.equ	p_temp1,0x10		# temporary for get/put bits operation
+.equ	p_temp2,0x20		# temporary for get/put bits operation
+.equ	p_xmm6,	0x30		# temporary for get/put bits operation
+.equ	p_xmm7,	0x40		# temporary for get/put bits operation
+.equ	p_xmm8,	0x50		# temporary for get/put bits operation
+.equ	p_xmm9,	0x60		# temporary for get/put bits operation
+.equ	p_xmm10,0x70		# temporary for get/put bits operation
+.equ	p_xmm11,0x80		# temporary for get/put bits operation
+.equ	p_xmm12,0x90		# temporary for get/put bits operation
+.equ	p_xmm13,0x0A0		# temporary for get/put bits operation
+.equ	p_xmm14,0x0B0		# temporary for get/put bits operation
+.equ	p_xmm15,0x0C0		# temporary for get/put bits operation
+.equ	r,	0x0D0			# pointer to r for remainder_piby2
+.equ	rr,	0x0E0		# pointer to r for remainder_piby2
+.equ	region,	0x0F0		# pointer to r for remainder_piby2
+.equ	p_original,0x100	# original x
+.equ	p_mask,	0x110		# original x
+.equ	p_sign,	0x120		# original x
+
+.globl __vrd2_cos
+    .type   __vrd2_cos,@function
+__vrd2_cos:
+	sub		$0x138,%rsp
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#STARTMAIN
+movdqa	%xmm0, p_original(%rsp)
+andpd 	.L__real_7fffffffffffffff(%rip),%xmm0
+movdqa 	%xmm0, p_temp(%rsp)
+mov 	$0x3FE921FB54442D18,%rdx			#piby4
+mov	$0x411E848000000000,%r10			#5e5
+movapd	.L__real_v2p__27(%rip),%xmm4			#for later use
+
+movapd	%xmm0,%xmm2					#x
+movapd	%xmm0,%xmm4					#x
+
+mov    	 p_temp(%rsp),%rax				#rax = lower arg
+mov    	 p_temp+8(%rsp),%rcx				#rcx = upper arg
+movapd	.L__real_3fe0000000000000(%rip),%xmm5		#0.5 for later use
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Leither_or_both_arg_gt_than_piby4:
+	cmp	%r10,%rax				#is lower arg >= 5e5
+	jae	.Llower_or_both_arg_gt_5e5
+	cmp	%r10,%rcx				#is upper arg >= 5e5
+	jae	.Lupper_arg_gt_5e5
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lboth_arg_lt_than_5e5:
+# %xmm2,,%xmm0 xmm4 = x, xmm5 = 0.5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm2	# x*twobypi
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm3	# xmm3=piby2_1
+	addpd	%xmm5,%xmm2				# xmm2 = npi2 = x*twobypi+0.5
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm1	# xmm1=piby2_2
+	movapd	.L__real_3ba3198a2e037073(%rip),%xmm6	# xmm6=piby2_2tail
+	cvttpd2dq	%xmm2,%xmm0			# xmm0=convert npi2 to ints
+	cvtdq2pd	%xmm0,%xmm2			# xmm2=and back to double.
+
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulpd	%xmm2,%xmm3				# npi2 * piby2_1
+	subpd	%xmm3,%xmm4				# xmm4 = rhead=x-npi2*piby2_1
+
+#t  = rhead;
+       movapd	%xmm4,%xmm5				# xmm5=t=rhead
+
+#rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm1				# xmm1= npi2*piby2_2
+
+#rhead  = t - rtail;
+       subpd	%xmm1,%xmm4				# xmm4= rhead = t-rtail
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	%xmm2,%xmm6     				# npi2 * piby2_2tail
+       subpd	%xmm4,%xmm5				# t-rhead
+       subpd	%xmm5,%xmm1				# rtail-(t - rhead)
+       addpd	%xmm6,%xmm1				# rtail=npi2*piby2_2+(rtail-(t-rhead))
+
+#r = rhead - rtail
+#rr=(rhead-r) -rtail
+#Sign
+#Region
+	movdqa		%xmm0,%xmm5			# Sign
+	movdqa		%xmm0,%xmm6			# Region
+	movdqa		%xmm4,%xmm0			# rhead (handle xmm0 retype)
+
+	paddd		.L__reald_one_one(%rip),%xmm6	# Sign
+	pand		.L__reald_two_two(%rip),%xmm6
+	punpckldq 	%xmm6,%xmm6
+	psllq		$62,%xmm6				# xmm6 is in Int format
+
+	subpd	%xmm1,%xmm0				# rhead - rtail
+	pand 	.L__reald_one_one(%rip),%xmm5		# Odd/Even region for Sin/Cos
+	mov 	.L__reald_one_zero(%rip),%r9		# Compare value for sincos
+	subpd	%xmm0,%xmm4				# rr=rhead-r
+	movd 	%xmm5,%r8				# Region
+	movapd	%xmm0,%xmm2				# Move for x2
+	movdqa	%xmm6,%xmm6				# handle xmm6 retype
+	mulpd	%xmm0,%xmm2				# x2
+	subpd	%xmm1,%xmm4				# rr=(rhead-r) -rtail
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#xmm0= x, xmm2 = x2, xmm4 = xx, r8 = region, r9 = compare value for sincos path, xmm6 = Sign
+
+.align 16
+.L__vrd2_cos_approximate:
+	cmp 	$0,%r8
+	jnz	.Lvrd2_not_cos_piby4
+
+.Lvrd2_cos_piby4:
+	mulpd	%xmm0,%xmm4				# x*xx
+	movdqa	.L__real_3fe0000000000000(%rip),%xmm5	# 0.5 (handle xmm5 retype)
+	movapd	.Lcosarray+0x50(%rip),%xmm1		# c6
+	movapd	.Lcosarray+0x20(%rip),%xmm0		# c3
+	mulpd	%xmm2,%xmm5				# r = 0.5 *x2
+	movapd	%xmm2,%xmm3				# copy of x2 for x4
+	movapd	 %xmm4,p_temp(%rsp)		# store x*xx
+	mulpd	%xmm2,%xmm1				# c6*x2
+	mulpd	%xmm2,%xmm0				# c3*x2
+	subpd	.L__real_3ff0000000000000(%rip),%xmm5	# -t=r-1.0
+	mulpd	%xmm2,%xmm3				# x4
+	addpd	.Lcosarray+0x40(%rip),%xmm1		# c5+x2c6
+	addpd	.Lcosarray+0x10(%rip),%xmm0		# c2+x2C3
+	addpd   .L__real_3ff0000000000000(%rip),%xmm5	# 1 + (-t)
+	mulpd	%xmm2,%xmm3				# x6
+	mulpd	%xmm2,%xmm1				# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm0				# x2(c2+x2C3)
+	movapd 	%xmm2,%xmm4				# copy of x2
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm4	# r = 0.5 *x2
+	addpd	.Lcosarray+0x30(%rip),%xmm1		# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray(%rip),%xmm0			# c1+x2(c2+x2C3)
+	mulpd	%xmm2,%xmm2				# x4
+	subpd   %xmm4,%xmm5				# (1 + (-t)) - r
+	mulpd	%xmm3,%xmm1				# x6(c4 + x2(c5+x2c6))
+	addpd	%xmm1,%xmm0				# zc
+	subpd	.L__real_3ff0000000000000(%rip),%xmm4	# -t=r-1.0
+	subpd	p_temp(%rsp),%xmm5		# ((1 + (-t)) - r) - x*xx
+	mulpd	%xmm2,%xmm0				# x4 * zc
+	addpd   %xmm5,%xmm0				# x4 * zc + ((1 + (-t)) - r -x*xx)
+	subpd   %xmm4,%xmm0				# result - (-t)
+	xorpd	%xmm6,%xmm0				# xor with sign
+	jmp 	.L__vrd2_cos_cleanup
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lvrd2_not_cos_piby4:
+	cmp 	$1,%r8
+	jnz	.Lvrd2_not_cos_sin_piby4
+
+.Lvrd2_cos_sin_piby4:
+
+	movdqa	 %xmm6,p_temp1(%rsp)		# Store Sign
+	movapd	 %xmm4,p_temp(%rsp)		# Store rr
+
+	movapd	.Lsincosarray+0x50(%rip),%xmm3		# s6
+	mulpd	%xmm2,%xmm3				# x2s6
+	movdqa	.Lsincosarray+0x20(%rip),%xmm5		# s3 (handle xmm5 retype)
+	movapd	%xmm2,%xmm1				# move x2 for x4
+	mulpd	%xmm2,%xmm1				# x4
+	mulpd	%xmm2,%xmm5				# x2s3
+	addpd	.Lsincosarray+0x40(%rip),%xmm3		# s5+x2s6
+	movapd	%xmm2,%xmm4				# move x2 for x6
+	mulpd	%xmm2,%xmm3				# x2(s5+x2s6)
+	mulpd	%xmm1,%xmm4				# x6
+	addpd	.Lsincosarray+0x10(%rip),%xmm5		# s2+x2s3
+	mulpd	%xmm2,%xmm5				# x2(s2+x2s3)
+	addpd	.Lsincosarray+0x30(%rip),%xmm3		# s4+x2(s5+x2s6)
+
+	movhlps	%xmm1,%xmm1				# move high x4 for cos
+	mulpd	%xmm4,%xmm3				# x6(s4+x2(s5+x2s6))
+	addpd	.Lsincosarray(%rip),%xmm5		# s1+x2(s2+x2s3)
+	movapd	%xmm2,%xmm4				# move low x2 for x3
+	mulsd	%xmm0,%xmm4				# get low x3 for sin term
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2
+
+	addpd	%xmm3,%xmm5				# z
+	movhlps	%xmm2,%xmm6				# move high r for cos
+	movhlps	%xmm5,%xmm3				# xmm5 = sin
+							# xmm3 = cos
+
+
+	mulsd	p_temp(%rsp),%xmm2		# 0.5 * x2 * xx
+
+	mulsd	%xmm4,%xmm5				# sin *x3
+	movsd	.L__real_3ff0000000000000(%rip),%xmm4	# 1.0
+	mulsd	%xmm1,%xmm3				# cos *x4
+	subsd	%xmm6,%xmm4 				# t=1.0-r
+
+	movhlps	%xmm0,%xmm1
+	subsd	%xmm2,%xmm5				# sin - 0.5 * x2 *xx
+
+	mulsd	p_temp+8(%rsp),%xmm1			# x * xx
+	movsd	.L__real_3ff0000000000000(%rip),%xmm2	# 1
+	subsd	%xmm4,%xmm2				# 1 - t
+	addsd	p_temp(%rsp),%xmm5			# sin+xx
+
+	subsd	%xmm6,%xmm2				# (1-t) - r
+	subsd	%xmm1,%xmm2				# ((1 + (-t)) - r) - x*xx
+	addsd	%xmm5,%xmm0				# sin + x
+	addsd   %xmm2,%xmm3				# cos+((1-t)-r - x*xx)
+	addsd   %xmm4,%xmm3				# cos+t
+
+	movapd	p_temp1(%rsp),%xmm5		# load sign
+	movlhps %xmm3,%xmm0
+	xorpd	%xmm5,%xmm0
+	jmp .L__vrd2_cos_cleanup
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lvrd2_not_cos_sin_piby4:
+	cmp 	%r9,%r8
+	jnz	.Lvrd2_sin_piby4
+
+.Lvrd2_sin_cos_piby4:
+
+	movapd	 %xmm4,p_temp(%rsp)		# rr move to to memory
+	movapd	 %xmm0,p_temp1(%rsp)		# r move to to memory
+	movapd	 %xmm6,p_sign(%rsp)
+
+	movapd	.Lcossinarray+0x50(%rip),%xmm3		# s6
+	mulpd	%xmm2,%xmm3				# x2s6
+	movdqa	.Lcossinarray+0x20(%rip),%xmm5		# s3
+	movapd	%xmm2,%xmm1				# move x2 for x4
+	mulpd	%xmm2,%xmm1				# x4
+	mulpd	%xmm2,%xmm5				# x2s3
+
+	addpd	.Lcossinarray+0x40(%rip),%xmm3		# s5+x2s6
+	movapd	%xmm2,%xmm4				# move for x6
+	mulpd	%xmm2,%xmm3				# x2(s5+x2s6)
+	mulpd	%xmm1,%xmm4				# x6
+	addpd	.Lcossinarray+0x10(%rip),%xmm5		# s2+x2s3
+	mulpd	%xmm2,%xmm5				# x2(s2+x2s3)
+	addpd	.Lcossinarray+0x30(%rip),%xmm3		# s4 + x2(s5+x2s6)
+
+	movhlps	%xmm0,%xmm0				# high of x for x3
+	mulpd	%xmm4,%xmm3				# x6(s4 + x2(s5+x2s6))
+	addpd	.Lcossinarray(%rip),%xmm5		# s1+x2(s2+x2s3)
+
+	movhlps	%xmm2,%xmm4				# high of x2 for x3
+
+	addpd	%xmm5,%xmm3				# z
+
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2
+	mulsd	%xmm0,%xmm4				# x3 #
+	movhlps	%xmm3,%xmm5				# xmm5 = sin
+							# xmm3 = cos
+
+	mulsd	%xmm4,%xmm5				# sin*x3 #
+	movsd	.L__real_3ff0000000000000(%rip),%xmm4	# 1.0 #
+	mulsd	%xmm1,%xmm3				# cos*x4 #
+
+	subsd	%xmm2,%xmm4 				# t=1.0-r #
+
+	movhlps	%xmm2,%xmm6				# move 0.5 * x2 for 0.5 * x2 * xx #
+	mulsd	p_temp+8(%rsp),%xmm6		# 0.5 * x2 * xx #
+	subsd	%xmm6,%xmm5				# sin - 0.5 * x2 *xx #
+	addsd	p_temp+8(%rsp),%xmm5		# sin+xx #
+
+	movlpd	p_temp1(%rsp),%xmm6		# x
+	mulsd	p_temp(%rsp),%xmm6		# x *xx #
+
+	movsd	.L__real_3ff0000000000000(%rip),%xmm1	# 1 #
+	subsd	%xmm4,%xmm1				# 1 -t #
+	addsd	%xmm5,%xmm0				# sin+x #
+	subsd	%xmm2,%xmm1				# (1-t) - r #
+	subsd	%xmm6,%xmm1				# ((1 + (-t)) - r) - x*xx #
+	addsd   %xmm1,%xmm3				# cos+((1 + (-t)) - r) - x*xx #
+	addsd   %xmm4,%xmm3				# cos+t #
+
+	movapd	p_sign(%rsp),%xmm2		# load sign
+	movlhps %xmm0,%xmm3
+	movapd	%xmm3,%xmm0
+	xorpd	%xmm2,%xmm0
+	jmp 	.L__vrd2_cos_cleanup
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lvrd2_sin_piby4:
+	movapd	.Lsinarray+0x50(%rip),%xmm3	# s6
+	mulpd	%xmm2,%xmm3			# x2s6
+	movapd	.Lsinarray+0x20(%rip),%xmm5	# s3
+	movapd	 %xmm4,p_temp(%rsp)	# store xx
+	movapd	%xmm2,%xmm1			# move for x4
+	mulpd	%xmm2,%xmm1			# x4
+	movapd	 %xmm0,p_temp1(%rsp)	# store x
+
+	mulpd	%xmm2,%xmm5			# x2s3
+	movapd 	%xmm0,%xmm4			# move for x3
+	addpd	.Lsinarray+0x40(%rip),%xmm3	# s5+x2s6
+	mulpd	%xmm2,%xmm1			# x6
+	mulpd	%xmm2,%xmm3			# x2(s5+x2s6)
+	mulpd	%xmm2,%xmm4			# x3
+	addpd	.Lsinarray+0x10(%rip),%xmm5	# s2+x2s3
+	mulpd	%xmm2,%xmm5			# x2(s2+x2s3)
+	addpd	.Lsinarray+0x30(%rip),%xmm3	# s4 + x2(s5+x2s6)
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm2 # 0.5 *x2
+
+	movapd	p_temp(%rsp),%xmm0		# load xx
+	mulpd	%xmm1,%xmm3			# x6(s4 + x2(s5+x2s6))
+	addpd	.Lsinarray(%rip),%xmm5		# s1+x2(s2+x2s3)
+	mulpd	%xmm0,%xmm2			# 0.5 * x2 *xx
+	addpd	%xmm5,%xmm3			# zs
+	mulpd	%xmm3,%xmm4			# *x3
+	subpd	%xmm2,%xmm4			# x3*zs - 0.5 * x2 *xx
+	addpd	%xmm4,%xmm0			# +xx
+	addpd	p_temp1(%rsp),%xmm0	# +x
+
+	xorpd	%xmm6,%xmm0			# xor sign
+	jmp 	.L__vrd2_cos_cleanup
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Llower_or_both_arg_gt_5e5:
+	cmp	%r10,%rcx				#is upper arg >= 5e5
+	jae	.Lboth_arg_gt_5e5
+
+.Llower_arg_gt_5e5:
+# Upper Arg is < 5e5, Lower arg is >= 5e5
+
+	movlpd	 %xmm0,r(%rsp)		#Save lower fp arg for remainder_piby2 call
+	movhlps	 %xmm0,%xmm0			#Needed since we want to work on upper arg
+	movhlps	 %xmm2,%xmm2
+	movhlps	 %xmm4,%xmm4
+
+# Work on Upper arg
+# %xmm2,,%xmm0 xmm4 = x, xmm5 = 0.5
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+
+#If upper Arg is <=piby4
+       cmp	%rdx,%rcx					# is upper arg > piby4
+       ja	0f
+
+       mov 	$0,%ecx						# region = 0
+       mov	 %ecx,region+4(%rsp)			# store upper region
+       movlpd	 %xmm0,r+8(%rsp)			# store upper r
+       xorpd	%xmm4,%xmm4					# rr = 0
+       movlpd	 %xmm4,rr+8(%rsp)			# store upper rr
+       jmp	.Lcheck_lower_arg
+
+.align 16
+0:
+#If upper Arg is > piby4
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm5,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm3		# xmm3 = piby2_1
+	cvttsd2si	%xmm2,%ecx				# xmm0 = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm1		# xmm1 = piby2_2
+	cvtsi2sd	%ecx,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm3					# npi2 * piby2_1
+	subsd	%xmm3,%xmm4					# xmm4 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm4,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm1					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm1,%xmm4					# xmm4 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm4,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm1					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm1					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %ecx,region+4(%rsp)			# store upper region
+       movsd	%xmm4,%xmm0
+       subsd	%xmm1,%xmm0					# xmm0 = r=(rhead-rtail)
+       subsd	%xmm0,%xmm4					# rr=rhead-r
+       subsd	%xmm1,%xmm4					# xmm4 = rr=((rhead-r) -rtail)
+       movlpd	 %xmm0,r+8(%rsp)				# store upper r
+       movlpd	 %xmm4,rr+8(%rsp)				# store upper rr
+
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+.align 16
+.Lcheck_lower_arg:
+	mov		$0x07ff0000000000000,%r11			# is lower arg nan/inf
+	mov		%r11,%r10
+	and		%rax,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd2_cos_lower_naninf
+
+	lea	 region(%rsp),%rdx			# lower arg is **NOT** nan/inf
+	lea	 rr(%rsp),%rsi
+	lea	 r(%rsp),%rdi
+	movlpd	 r(%rsp),%xmm0	#Restore lower fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+	jmp 	0f
+
+.L__vrd2_cos_lower_naninf:
+	mov	p_original(%rsp),%rax			# upper arg is nan/inf
+
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rax
+	mov	 %rax,r(%rsp)				# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr(%rsp)				# rr = 0
+	mov	 %r10d,region(%rsp)			# region =0
+
+.align 16
+0:
+	jmp .L__vrd2_cos_reconstruct
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lupper_arg_gt_5e5:
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+	movhpd	 %xmm0,r+8(%rsp)		#Save upper fp arg for remainder_piby2 call
+	movlhps	%xmm0,%xmm0			#Not needed since we want to work on lower arg, but done just to be safe and avoide exceptions due to nan/inf and to mirror the lower_arg_gt_5e5 case
+	movlhps	%xmm2,%xmm2
+	movlhps	%xmm4,%xmm4
+
+
+# Work on Lower arg
+# %xmm2,,%xmm0 xmm4 = x, xmm5 = 0.5
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+
+#If lower Arg is <=piby4
+       cmp	%rdx,%rax					# is upper arg > piby4
+       ja	0f
+
+       mov 	$0,%eax						# region = 0
+       mov	 %eax,region(%rsp)			# store upper region
+       movlpd	 %xmm0,r(%rsp)				# store upper r
+       xorpd	%xmm4,%xmm4					# rr = 0
+       movlpd	 %xmm4,rr(%rsp)				# store upper rr
+       jmp 	.Lcheck_upper_arg
+
+.align 16
+0:
+#If upper Arg is > piby4
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm5,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm3		# xmm3 = piby2_1
+	cvttsd2si	%xmm2,%eax				# xmm0 = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm1		# xmm1 = piby2_2
+	cvtsi2sd	%eax,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm3					# npi2 * piby2_1
+	subsd	%xmm3,%xmm4					# xmm4 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm4,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm1					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm1,%xmm4					# xmm4 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm4,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm1					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm1					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %eax,region(%rsp)			# store lower region
+       movsd	%xmm4,%xmm0
+       subsd	%xmm1,%xmm0					# xmm0 = r=(rhead-rtail)
+       subsd	%xmm0,%xmm4					# rr=rhead-r
+       subsd	%xmm1,%xmm4					# xmm4 = rr=((rhead-r) -rtail)
+       movlpd	 %xmm0,r(%rsp)				# store lower r
+       movlpd	 %xmm4,rr(%rsp)				# store lower rr
+
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+.align 16
+.Lcheck_upper_arg:
+	mov		$0x07ff0000000000000,%r11			# is upper arg nan/inf
+	mov		%r11,%r10
+	and		%rcx,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd2_cos_upper_naninf
+
+	lea	 region+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 rr+8(%rsp),%rsi
+	lea	 r+8(%rsp),%rdi
+	movlpd	 r+8(%rsp),%xmm0			#Restore upper fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+	jmp 	0f
+
+.L__vrd2_cos_upper_naninf:
+	mov	p_original+8(%rsp),%rcx		# upper arg is nan/inf
+
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rcx
+	mov	%rcx,r+8(%rsp)				# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	%r10,rr+8(%rsp)			# rr = 0
+	mov	%r10d,region+4(%rsp)			# region =0
+
+.align 16
+0:
+	jmp .L__vrd2_cos_reconstruct
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lboth_arg_gt_5e5:
+#Upper Arg is >= 5e5, Lower arg is >= 5e5
+
+#	movhlps %xmm0, %xmm6		#Save upper fp arg for remainder_piby2 call
+	movhpd  %xmm0, p_temp1(%rsp)	#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r11			#is lower arg nan/inf
+	mov		%r11,%r10
+	and		%rax,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd2_cos_lower_naninf_of_both_gt_5e5
+
+	lea	 region(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	 rr(%rsp),%rsi
+	lea	 r(%rsp),%rdi
+	mov	  %rcx,p_temp(%rsp)			#Save upper arg
+        call    __amd_remainder_piby2@PLT
+	mov	 p_temp(%rsp),%rcx			#Restore upper arg
+	jmp 	0f
+
+.L__vrd2_cos_lower_naninf_of_both_gt_5e5:				#lower arg is nan/inf
+	mov	p_original(%rsp),%rax
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rax
+	mov	 %rax,r(%rsp)				#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr(%rsp)				#rr = 0
+	mov	 %r10d,region(%rsp)			#region = 0
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r11			#is upper arg nan/inf
+	mov		%r11,%r10
+	and		%rcx,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd2_cos_upper_naninf_of_both_gt_5e5
+
+	lea	 region+4(%rsp),%rdx			#upper arg is **NOT** nan/inf
+	lea	 rr+8(%rsp),%rsi
+	lea	 r+8(%rsp),%rdi
+	movlpd	 p_temp1(%rsp),%xmm0			#Restore upper fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+	jmp 	0f
+
+.L__vrd2_cos_upper_naninf_of_both_gt_5e5:
+	mov	p_original+8(%rsp),%rcx		#upper arg is nan/inf
+#	movd	%xmm6,%rcx					;upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rcx
+	mov	 %rcx,r+8(%rsp)				#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr+8(%rsp)			#rr = 0
+	mov	 %r10d,region+4(%rsp)			#region = 0
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+0:
+.L__vrd2_cos_reconstruct:
+#Construct xmm0=x, xmm2 =x2, xmm4=xx, r8=region, xmm6=sign
+	movapd	r(%rsp),%xmm0				#x
+	movapd	%xmm0,%xmm2					#move for x2
+	mulpd	%xmm2,%xmm2					#x2
+
+	movapd	rr(%rsp),%xmm4				#xx
+
+	mov	region(%rsp),%r8
+	mov 	.L__reald_one_zero(%rip),%r9		#compare value for sincos path
+	mov 	%r8,%r10
+	and	.L__reald_one_one(%rip),%r8		#odd/even region for sin/cos
+	add	.L__reald_one_one(%rip),%r10
+	and	.L__reald_two_two(%rip),%r10
+	mov	%r10,%r11
+	and	.L__reald_two_zero(%rip),%r11		#mask out the lower sign bit leaving the upper sign bit
+	shl	$62,%r10				#shift lower sign bit left by 63 bits
+	shl	$30,%r11				#shift upper sign bit left by 31 bits
+	mov 	 %r10,p_temp(%rsp)		#write out lower sign bit
+	mov 	 %r11,p_temp+8(%rsp)		#write out upper sign bit
+	movapd	p_temp(%rsp),%xmm6		#write out both sign bits to xmm6
+
+	jmp 	.L__vrd2_cos_approximate
+
+#ENDMAIN
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrd2_cos_cleanup:
+	add	$0x138,%rsp
+	ret
diff --git a/src/gas/vrd2exp.S b/src/gas/vrd2exp.S
new file mode 100644
index 0000000..b87763f
--- /dev/null
+++ b/src/gas/vrd2exp.S
@@ -0,0 +1,372 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# exp.asm
+#
+# A vector implementation of the exp libm function.
+#
+# Prototype:
+#
+#     __m128d __vrd2_exp(__m128d x);
+#
+#   Computes e raised to the x power.
+# Does not perform error checking.   Denormal results are truncated to 0.
+#
+#
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+
+        .text
+        .align 16
+        .p2align 4,,15
+
+# define local variable storage offsets
+.equ    p_temp,0        # temporary for get/put bits operation
+.equ    p_temp1,0x10        # temporary for get/put bits operation
+.equ    stack_size,0x28
+
+
+
+
+.globl __vrd2_exp
+       .type   __vrd2_exp,@function
+__vrd2_exp:
+        sub     $stack_size,%rsp
+
+
+
+#        /* Find m, z1 and z2 such that exp(x) = 2**m * (z1 + z2) */
+#      Step 1. Reduce the argument.
+	#    r = x * thirtytwo_by_logbaseof2;
+	movapd	%xmm0,p_temp(%rsp)
+	movapd	.L__real_thirtytwo_by_log2(%rip),%xmm3	#
+	maxpd	.L__real_C0F0000000000000(%rip),%xmm0	# protect against very large negative, non-infinite numbers
+	mulpd	%xmm0,%xmm3
+
+# save x for later.
+        minpd   .L__real_40F0000000000000(%rip),%xmm3    # protect against very large, non-infinite numbers
+
+#    /* Set n = nearest integer to r */
+	cvtpd2dq	%xmm3,%xmm4
+	lea		.L__two_to_jby32_lead_table(%rip),%rdi
+	lea		.L__two_to_jby32_trail_table(%rip),%rsi
+	cvtdq2pd	%xmm4,%xmm1
+
+ #    r1 = x - n * logbaseof2_by_32_lead;
+	movapd	.L__real_log2_by_32_lead(%rip),%xmm2	#
+	mulpd	%xmm1,%xmm2				#
+	movq	 %xmm4,p_temp1(%rsp)
+	subpd	%xmm2,%xmm0	 			# r1 in xmm0,
+
+#    r2 =   - n * logbaseof2_by_32_trail;
+	mulpd	 .L__real_log2_by_32_tail(%rip),%xmm1 	# r2 in xmm1
+#    j = n & 0x0000001f;
+	mov		$0x01f,%r9
+	mov		%r9,%r8
+	mov		p_temp1(%rsp),%ecx
+	and		%ecx,%r9d
+
+	mov		p_temp1+4(%rsp),%edx
+	and		%edx,%r8d
+	movapd	%xmm0,%xmm2
+#    f1 = two_to_jby32_lead_table[j];
+#    f2 = two_to_jby32_trail_table[j];
+
+#    *m = (n - j) / 32;
+	sub		%r9d,%ecx
+	sar		$5,%ecx			#m
+	sub		%r8d,%edx
+	sar		$5,%edx
+
+
+	addpd	%xmm1,%xmm2    #r = r1 + r2
+
+#      Step 2. Compute the polynomial.
+#    q = r1 + (r2 +
+#              r*r*( 5.00000000000000008883e-01 +
+#                      r*( 1.66666666665260878863e-01 +
+#                      r*( 4.16666666662260795726e-02 +
+#                      r*( 8.33336798434219616221e-03 +
+#                      r*( 1.38889490863777199667e-03 ))))));
+#    q = r + r^2/2 + r^3/6 + r^4/24 + r^5/120 + r^6/720
+	movapd	%xmm2,%xmm1
+	movapd	 .L__real_3f56c1728d739765(%rip),%xmm3	# 	1/720
+	movapd	 .L__real_3FC5555555548F7C(%rip),%xmm0 	# 	1/6
+# deal with infinite results
+	mov		$1024,%rax
+	movsx	%ecx,%rcx
+	cmp		%rax,%rcx
+
+	mulpd	%xmm2,%xmm3			# *x
+	mulpd	%xmm2,%xmm0			# *x
+	mulpd	%xmm2,%xmm1			# x*x
+	movapd	%xmm1,%xmm4
+
+	cmovg	%rax,%rcx			## if infinite, then set rcx to multiply
+						# by infinity
+	movsx	%edx,%rdx
+	cmp	%rax,%rdx
+
+	addpd	 .L__real_3F811115B7AA905E(%rip),%xmm3 	# 	+ 1/120
+	addpd	 .L__real_3fe0000000000000(%rip),%xmm0 	# 	+ .5
+	mulpd	%xmm1,%xmm4								# x^4
+	mulpd	%xmm2,%xmm3								# *x
+
+	cmovg	%rax,%rdx			## if infinite, then set rcx to multiply
+						# by infinity
+# deal with denormal results
+	xor		%rax,%rax
+	add		$1023,%rcx		# add bias
+
+	mulpd	%xmm1,%xmm0			# *x^2
+	addpd	 .L__real_3FA5555555545D4E(%rip),%xmm3 	# 	+ 1/24
+	addpd	%xmm2,%xmm0			# 	+ x
+	mulpd	%xmm4,%xmm3			# *x^4
+# check for infinity or nan
+	movapd	 p_temp(%rsp),%xmm2
+	cmovs	%rax,%rcx			## if denormal, then multiply by 0
+	shl		$52,%rcx		# build 2^n
+
+	addpd	%xmm3,%xmm0			# q = final sum
+
+#    *z2 = f2 + ((f1 + f2) * q);
+	movlpd	(%rsi,%r9,8),%xmm5 		# f2
+	movlpd	(%rsi,%r8,8),%xmm4 		# f2
+	addsd	(%rdi,%r9,8),%xmm5		# f1 + f2
+
+	addsd	(%rdi,%r8,8),%xmm4		# f1 + f2
+	shufpd	$0,%xmm4,%xmm5
+
+
+	mulpd	%xmm5,%xmm0
+	add		$1023,%rdx		# add bias
+	cmovs	%rax,%rdx			## if denormal, then multiply by 0
+	addpd	%xmm5,%xmm0			#z = z1 + z2
+# end of splitexp
+#        /* Scale (z1 + z2) by 2.0**m */
+#          r = scaleDouble_1(z, n);
+
+#;;; the following code moved to improve scheduling
+# deal with infinite results
+#	mov		$1024,%rax
+#	movsxd	%ecx,%rcx
+#	cmp		%rax,%rcx
+#	cmovg	%rax,%rcx					; if infinite, then set rcx to multiply
+									# by infinity
+#	movsxd	%edx,%rdx
+#	cmp		%rax,%rdx
+#	cmovg	%rax,%rdx					; if infinite, then set rcx to multiply
+									# by infinity
+
+# deal with denormal results
+#	xor		%rax,%rax
+#	add		$1023,%rcx				; add bias
+#	shl		$52,%rcx					; build 2^n
+
+#	add		$1023,%rdx				; add bias
+	shl		$52,%rdx					# build 2^n
+
+# check for infinity or nan
+#	movapd	 p_temp(%rsp),%xmm2
+	andpd	 .L__real_infinity(%rip),%xmm2
+	cmppd	 $0,.L__real_infinity(%rip),%xmm2
+	mov		%rcx,p_temp1(%rsp) 	# get 2^n to memory
+	mov		%rdx,p_temp1+8(%rsp) 	# get 2^n to memory
+	movmskpd	%xmm2,%r8d
+	test		$3,%r8d
+
+#      Step 3. Reconstitute.
+
+	mulpd	 p_temp1(%rsp),%xmm0 	# result*= 2^n
+
+# we'd like to avoid a branch, and can use cmp's and and's to
+# eliminate them.  But it adds cycles for normal cases which
+# are supposed to be exceptions.  Using this branch with the
+# check above results in faster code for the normal cases.
+	jnz			.L__exp_naninf
+
+#
+#
+.L__final_check:
+	add		$stack_size,%rsp
+	ret
+
+# at least one of the numbers needs special treatment
+.L__exp_naninf:
+# check the first number
+	test	$1,%r8d
+	jz		.L__check2
+
+	mov		p_temp(%rsp),%rdx
+	mov		$0x0000FFFFFFFFFFFFF,%rax
+	test	%rax,%rdx
+	jnz		.L__enan1		# jump if mantissa not zero, so it's a NaN
+# inf
+	mov		%rdx,%rax
+	rcl		$1,%rax
+	jnc		.L__r1			# exp(+inf) = inf
+	xor		%rdx,%rdx		# exp(-inf) = 0
+	jmp		.L__r1
+
+#NaN
+.L__enan1:
+	mov		$0x00008000000000000,%rax	# convert to quiet
+	or		%rax,%rdx
+.L__r1:
+	movd	%rdx,%xmm2
+	shufpd	$2,%xmm0,%xmm2
+	movsd	%xmm2,%xmm0
+# check the second number
+.L__check2:
+	test	$2,%r8d
+	jz		.L__final_check
+	mov		p_temp+8(%rsp),%rdx
+	mov		$0x0000FFFFFFFFFFFFF,%rax
+	test	%rax,%rdx
+	jnz		.L__enan2		# jump if mantissa not zero, so it's a NaN
+# inf
+	mov		%rdx,%rax
+	rcl		$1,%rax
+	jnc		.L__r2			# exp(+inf) = inf
+	xor		%rdx,%rdx		# exp(-inf) = 0
+	jmp		.L__r2
+
+#NaN
+.L__enan2:
+	mov		$0x00008000000000000,%rax	# convert to quiet
+	or		%rax,%rdx
+.L__r2:
+	movd	%rdx,%xmm2
+	shufpd	$0,%xmm2,%xmm0
+	jmp		.L__final_check
+
+	.data
+        .align 16
+.L__real_3ff0000000000000: 	.quad 0x03ff0000000000000	# 1.0
+				.quad 0x03ff0000000000000	# for alignment
+.L__real_4040000000000000:	.quad 0x04040000000000000	# 32
+				.quad 0x04040000000000000
+.L__real_40F0000000000000:      .quad 0x040F0000000000000        # 65536, to protect agains t really large numbers
+				.quad 0x040F0000000000000
+.L__real_C0F0000000000000:	.quad 0x0C0F0000000000000	# -65536, to protect against really large negative numbers
+				.quad 0x0C0F0000000000000
+.L__real_3FA0000000000000:	.quad 0x03FA0000000000000	# 1/32
+				.quad 0x03FA0000000000000
+.L__real_3fe0000000000000:	.quad 0x03fe0000000000000	# 1/2
+				.quad 0x03fe0000000000000
+.L__real_infinity:		.quad 0x07ff0000000000000	#
+				.quad 0x07ff0000000000000	# for alignment
+.L__real_ninfinity:		.quad 0x0fff0000000000000	#
+				.quad 0x0fff0000000000000	# for alignment
+.L__real_thirtytwo_by_log2: 	.quad 0x040471547652b82fe	# thirtytwo_by_log2
+				.quad 0x040471547652b82fe
+.L__real_log2_by_32_lead:	.quad 0x03f962e42fe000000	# log2_by_32_lead
+				.quad 0x03f962e42fe000000
+.L__real_log2_by_32_tail:	.quad 0x0Bdcf473de6af278e	# -log2_by_32_tail
+				.quad 0x0Bdcf473de6af278e
+.L__real_3f56c1728d739765:	.quad 0x03f56c1728d739765	# 1.38889490863777199667e-03
+				.quad 0x03f56c1728d739765
+.L__real_3F811115B7AA905E:	.quad 0x03F811115B7AA905E	# 8.33336798434219616221e-03
+				.quad 0x03F811115B7AA905E
+.L__real_3FA5555555545D4E:	.quad 0x03FA5555555545D4E	# 4.16666666662260795726e-02
+				.quad 0x03FA5555555545D4E
+.L__real_3FC5555555548F7C:	.quad 0x03FC5555555548F7C	# 1.66666666665260878863e-01
+				.quad 0x03FC5555555548F7C
+
+
+.L__two_to_jby32_lead_table:
+	.quad	0x03ff0000000000000 # 1
+	.quad	0x03ff059b0d0000000		# 1.0219
+	.quad	0x03ff0b55860000000		# 1.04427
+	.quad	0x03ff11301d0000000		# 1.06714
+	.quad	0x03ff172b830000000		# 1.09051
+	.quad	0x03ff1d48730000000		# 1.11439
+	.quad	0x03ff2387a60000000		# 1.13879
+	.quad	0x03ff29e9df0000000		# 1.16372
+	.quad	0x03ff306fe00000000		# 1.18921
+	.quad	0x03ff371a730000000		# 1.21525
+	.quad	0x03ff3dea640000000		# 1.24186
+	.quad	0x03ff44e0860000000		# 1.26905
+	.quad	0x03ff4bfdad0000000		# 1.29684
+	.quad	0x03ff5342b50000000		# 1.32524
+	.quad	0x03ff5ab07d0000000		# 1.35426
+	.quad	0x03ff6247eb0000000		# 1.38391
+	.quad	0x03ff6a09e60000000		# 1.41421
+	.quad	0x03ff71f75e0000000		# 1.44518
+	.quad	0x03ff7a11470000000		# 1.47683
+	.quad	0x03ff8258990000000		# 1.50916
+	.quad	0x03ff8ace540000000		# 1.54221
+	.quad	0x03ff93737b0000000		# 1.57598
+	.quad	0x03ff9c49180000000		# 1.61049
+	.quad	0x03ffa5503b0000000		# 1.64576
+	.quad	0x03ffae89f90000000		# 1.68179
+	.quad	0x03ffb7f76f0000000		# 1.71862
+	.quad	0x03ffc199bd0000000		# 1.75625
+	.quad	0x03ffcb720d0000000		# 1.79471
+	.quad	0x03ffd5818d0000000		# 1.83401
+	.quad	0x03ffdfc9730000000		# 1.87417
+	.quad	0x03ffea4afa0000000		# 1.91521
+	.quad	0x03fff507650000000		# 1.95714
+	.quad 0					# for alignment
+.L__two_to_jby32_trail_table:
+	.quad	0x00000000000000000 # 0
+	.quad	0x03e48ac2ba1d73e2a		# 1.1489e-008
+	.quad	0x03e69f3121ec53172		# 4.83347e-008
+	.quad	0x03df25b50a4ebbf1b		# 2.67125e-010
+	.quad	0x03e68faa2f5b9bef9		# 4.65271e-008
+	.quad	0x03e368b9aa7805b80		# 5.24924e-009
+	.quad	0x03e6ceac470cd83f6		# 5.38622e-008
+	.quad	0x03e547f7b84b09745		# 1.90902e-008
+	.quad	0x03e64636e2a5bd1ab		# 3.79764e-008
+	.quad	0x03e5ceaa72a9c5154		# 2.69307e-008
+	.quad	0x03e682468446b6824		# 4.49684e-008
+	.quad	0x03e18624b40c4dbd0		# 1.41933e-009
+	.quad	0x03e54d8a89c750e5e		# 1.94147e-008
+	.quad	0x03e5a753e077c2a0f		# 2.46409e-008
+	.quad	0x03e6a90a852b19260		# 4.94813e-008
+	.quad	0x03e0d2ac258f87d03		# 8.48872e-010
+	.quad	0x03e59fcef32422cbf		# 2.42032e-008
+	.quad	0x03e61d8bee7ba46e2		# 3.3242e-008
+	.quad	0x03e4f580c36bea881		# 1.45957e-008
+	.quad	0x03e62999c25159f11		# 3.46453e-008
+	.quad	0x03e415506dadd3e2a		# 8.0709e-009
+	.quad	0x03e29b8bc9e8a0388		# 2.99439e-009
+	.quad	0x03e451f8480e3e236		# 9.83622e-009
+	.quad	0x03e41f12ae45a1224		# 8.35492e-009
+	.quad	0x03e62b5a75abd0e6a		# 3.48493e-008
+	.quad	0x03e47daf237553d84		# 1.11085e-008
+	.quad	0x03e6b0aa538444196		# 5.03689e-008
+	.quad	0x03e69df20d22a0798		# 4.81896e-008
+	.quad	0x03e69f7490e4bb40b		# 4.83654e-008
+	.quad	0x03e4bdcdaf5cb4656		# 1.29746e-008
+	.quad	0x03e452486cc2c7b9d		# 9.84533e-009
+	.quad	0x03e66dc8a80ce9f09		# 4.25828e-008
+	.quad 0					# for alignment
+
diff --git a/src/gas/vrd2log.S b/src/gas/vrd2log.S
new file mode 100644
index 0000000..30bb3b1
--- /dev/null
+++ b/src/gas/vrd2log.S
@@ -0,0 +1,573 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrd2log.s
+#
+# An implementation of the log libm function.
+#
+# Prototype:
+#
+#     __m128d __vrd2_log(__m128d x);
+#
+#   Computes the natural log of x.
+#   Returns proper C99 values, but may not raise status flags properly.
+#   Less than 1 ulp of error.  Runs 105-115 cycles for valid inputs.
+#
+#
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+# define local variable storage offsets
+.equ	p_x,0			# temporary for error checking operation
+.equ	p_idx,0x010		# index storage
+
+.equ	stack_size,0x028
+
+
+
+    .text
+    .align 16
+    .p2align 4,,15
+.globl __vrd2_log
+    .type   __vrd2_log,@function
+__vrd2_log:
+	sub		$stack_size,%rsp
+
+	movdqa	%xmm0,p_x(%rsp)	# save the input values
+
+
+#      /* Store the exponent of x in xexp and put
+#         f into the range [0.5,1) */
+
+#
+# compute the index into the log tables
+#
+	pxor	%xmm1,%xmm1
+	movdqa	%xmm0,%xmm3
+	psrlq	$52,%xmm3
+	psubq	.L__mask_1023(%rip),%xmm3
+	packssdw	%xmm1,%xmm3
+	cvtdq2pd	%xmm3,%xmm6			# xexp
+	movdqa	%xmm0,%xmm2
+	xor		%rax,%rax
+	subpd	.L__real_one(%rip),%xmm2
+
+	movdqa	%xmm0,%xmm3
+	andpd	.L__real_notsign(%rip),%xmm2
+	pand	.L__real_mant(%rip),%xmm3
+	movdqa	%xmm3,%xmm4
+	movapd	.L__real_half(%rip),%xmm5							# .5
+
+	cmppd	$1,.L__real_threshold(%rip),%xmm2
+	movmskpd	%xmm2,%r10d
+	cmp		$3,%r10d
+	jz		.Lall_nearone
+
+#/* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+	psrlq	$45,%xmm3
+	movdqa	%xmm3,%xmm2
+	psrlq	$1,%xmm3
+	paddq	.L__mask_040(%rip),%xmm3
+	pand	.L__mask_001(%rip),%xmm2
+	paddq	%xmm2,%xmm3
+
+	packssdw	%xmm1,%xmm3
+	cvtdq2pd	%xmm3,%xmm1
+	xor		%rcx,%rcx
+	movq	 %xmm3,p_idx(%rsp)
+
+# reduce and get u
+	por		.L__real_half(%rip),%xmm4
+	movdqa	%xmm4,%xmm2
+
+
+	mulpd	.L__real_3f80000000000000(%rip),%xmm1		# f1 = index/128
+
+
+	lea	.L__np_ln_lead_table(%rip),%rdx
+	mov	p_idx(%rsp),%eax
+
+	subpd	%xmm1,%xmm2				# f2 = f - f1
+	mulpd	%xmm2,%xmm5
+	addpd	%xmm5,%xmm1
+
+	divpd	%xmm1,%xmm2				# u
+
+# do error checking here for scheduling.  Saves a bunch of cycles as
+# compared to doing this at the start of the routine.
+##  if NaN or inf
+	movapd	%xmm0,%xmm3
+	andpd	.L__real_inf(%rip),%xmm3
+	cmppd	$0,.L__real_inf(%rip),%xmm3
+	movmskpd	%xmm3,%r8d
+	xorpd	%xmm1,%xmm1
+
+	cmppd	$2,%xmm1,%xmm0
+	movmskpd	%xmm0,%r9d
+
+# get z
+	movlpd	 -512(%rdx,%rax,8),%xmm0		# z1
+	mov		p_idx+4(%rsp),%ecx
+	movhpd	 -512(%rdx,%rcx,8),%xmm0		# z1
+# solve for ln(1+u)
+	movapd	%xmm2,%xmm1				# u
+	mulpd	%xmm2,%xmm2				# u^2
+	movapd	%xmm2,%xmm5
+	movapd	.L__real_cb3(%rip),%xmm3
+	mulpd	%xmm2,%xmm3				#Cu2
+	mulpd	%xmm1,%xmm5				# u^3
+	addpd	.L__real_cb2(%rip),%xmm3 		#B+Cu2
+
+	mulpd	%xmm5,%xmm2				# u^5
+	movapd	.L__real_log2_lead(%rip),%xmm4
+
+	mulpd	.L__real_cb1(%rip),%xmm5 		#Au3
+	addpd	%xmm5,%xmm1				# u+Au3
+	mulpd	%xmm3,%xmm2				# u5(B+Cu2)
+
+	addpd	%xmm2,%xmm1				# poly
+# recombine
+	mulpd	%xmm6,%xmm4				# xexp * log2_lead
+	addpd	%xmm4,%xmm0				#r1
+	lea		.L__np_ln_tail_table(%rip),%rdx
+	movlpd	 -512(%rdx,%rax,8),%xmm4		#z2	+=q
+	movhpd	 -512(%rdx,%rcx,8),%xmm4		#z2	+=q
+	addpd	%xmm4,%xmm1
+
+	mulpd	.L__real_log2_tail(%rip),%xmm6
+
+	addpd	%xmm6,%xmm1				#r2
+
+# check for nans/infs
+	test		$3,%r8d
+	addpd	%xmm1,%xmm0
+	jnz		.L__log_naninf
+.L__vlog1:
+# check for negative numbers or zero
+	test		$3,%r9d
+	jnz		.L__z_or_n
+
+.L__finish:
+# see if we have a near one value
+	test		 $3,%r10d
+	jnz		.L__near_one
+.L__finishn1:
+	add		$stack_size,%rsp
+	ret
+
+	.align	16
+.Lall_nearone:
+# saves 10 cycles
+#      r = x - 1.0;
+	movapd	.L__real_two(%rip),%xmm2
+	subpd	.L__real_one(%rip),%xmm0	   # r
+#      u          = r / (2.0 + r);
+	addpd	%xmm0,%xmm2
+	movapd	%xmm0,%xmm1
+	divpd	%xmm2,%xmm1			# u
+	movapd	.L__real_ca4(%rip),%xmm4	  #D
+	movapd	.L__real_ca3(%rip),%xmm5	  #C
+#      correction = r * u;
+	movapd	%xmm0,%xmm6
+	mulpd	%xmm1,%xmm6		# correction
+#      u          = u + u;
+	addpd	%xmm1,%xmm1		#u
+	movapd	%xmm1,%xmm2
+	mulpd	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulpd	%xmm1,%xmm5		# Cu
+	movapd	%xmm1,%xmm3
+	mulpd	%xmm2,%xmm3		# u^3
+	mulpd	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulpd	%xmm3,%xmm4		#Du^3
+
+	addpd	.L__real_ca1(%rip),%xmm2	# +A
+	movapd	%xmm3,%xmm1
+	mulpd	%xmm1,%xmm1		# u^6
+	addpd	%xmm4,%xmm5		#Cu+Du3
+#	subsd	%xmm6,%xmm0		; -correction
+
+	mulpd	%xmm3,%xmm2		#u3(A+Bu2)
+	mulpd	%xmm5,%xmm1		#u6(Cu+Du3)
+	addpd	%xmm1,%xmm2
+	subpd	%xmm6,%xmm2		# -correction
+
+#      return r + r2;
+	addpd	%xmm2,%xmm0
+	jmp		.L__finishn1
+
+	.align	16
+.L__near_one:
+	test	$1,%r10d
+	jz		.L__lnn12
+
+#	movapd	%xmm0,%xmm6		; save the inputs
+	movlpd	p_x(%rsp),%xmm0
+	call	.L__ln1
+#	shufpd	xmm0,$2,%xmm6
+
+.L__lnn12:
+	test	$2,%r10d		# second number?
+	jz		.L__lnn1e
+	movlpd	%xmm0,p_x(%rsp)
+	movlpd	p_x+8(%rsp),%xmm0
+	call	.L__ln1
+	movlpd	%xmm0,p_x+8(%rsp)
+	movapd	p_x(%rsp),%xmm0
+#	shufpd	xmm6,$0,%xmm0
+#	movapd	%xmm6,%xmm0
+
+.L__lnn1e:
+	jmp		.L__finishn1
+
+.L__ln1:
+# saves 10 cycles
+#      r = x - 1.0;
+	movlpd	.L__real_two(%rip),%xmm2
+	subsd	.L__real_one(%rip),%xmm0	# r
+#      u          = r / (2.0 + r);
+	addsd	%xmm0,%xmm2
+	movsd	%xmm0,%xmm1
+	divsd	%xmm2,%xmm1			# u
+	movlpd	.L__real_ca4(%rip),%xmm4	#D
+	movlpd	.L__real_ca3(%rip),%xmm5	#C
+#      correction = r * u;
+	movsd	%xmm0,%xmm6
+	mulsd	%xmm1,%xmm6		# correction
+#      u          = u + u;
+	addsd	%xmm1,%xmm1		#u
+	movsd	%xmm1,%xmm2
+	mulsd	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulsd	%xmm1,%xmm5		# Cu
+	movsd	%xmm1,%xmm3
+	mulsd	%xmm2,%xmm3		# u^3
+	mulsd	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulsd	%xmm3,%xmm4		#Du^3
+
+	addsd	.L__real_ca1(%rip),%xmm2	# +A
+	movsd	%xmm3,%xmm1
+	mulsd	%xmm1,%xmm1		# u^6
+	addsd	%xmm4,%xmm5		#Cu+Du3
+#	subsd	%xmm6,%xmm0		; -correction
+
+	mulsd	%xmm3,%xmm2		#u3(A+Bu2)
+	mulsd	%xmm5,%xmm1		#u6(Cu+Du3)
+	addsd	%xmm1,%xmm2
+	subsd	%xmm6,%xmm2		# -correction
+
+#      return r + r2;
+	addsd	%xmm2,%xmm0
+	ret
+
+	.align	16
+
+# at least one of the numbers was a nan or infinity
+.L__log_naninf:
+	test		$1,%r8d		# first number?
+	jz		.L__lninf2
+
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x(%rsp),%rdx
+	movlpd	p_x(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$2,%xmm1,%xmm0
+
+.L__lninf2:
+	test		$2,%r8d		# second number?
+	jz		.L__lninfe
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov	p_x+8(%rsp),%rdx
+	movlpd	p_x+8(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$0,%xmm0,%xmm1
+	movapd	%xmm1,%xmm0
+
+.L__lninfe:
+
+	cmp		$3,%r8d		# both numbers?
+	jz		.L__finish	# return early if so
+	jmp		.L__vlog1	# continue processing if not
+
+# a subroutine to treat one number for nan/infinity
+# the number is expected in rdx and returned in the low
+# half of xmm0
+.L__lni:
+	mov		$0x0000FFFFFFFFFFFFF,%rax
+	test	%rax,%rdx
+	jnz		.L__lnan	# jump if mantissa not zero, so it's a NaN
+# inf
+	rcl		$1,%rdx
+	jnc		.L__lne2	# log(+inf) = inf
+# negative x
+	movlpd	.L__real_nan(%rip),%xmm0
+	ret
+
+#NaN
+.L__lnan:
+	mov		$0x00008000000000000,%rax	# convert to quiet
+	or		%rax,%rdx
+.L__lne:
+	movd	%rdx,%xmm0
+.L__lne2:
+	ret
+
+	.align	16
+
+# at least one of the numbers was a zero, a negative number, or both.
+.L__z_or_n:
+	test		$1,%r9d		# first number?
+	jz		.L__zn2
+
+#	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x(%rsp),%rax
+	call	.L__zni
+#	shufpd	$2,%xmm1,%xmm0
+
+.L__zn2:
+	test		$2,%r9d		# second number?
+	jz		.L__zne
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x+8(%rsp),%rax
+	call	.L__zni
+	shufpd	$0,%xmm0,%xmm1
+	movapd	%xmm1,%xmm0
+
+.L__zne:
+	jmp		.L__finish
+
+# a subroutine to treat one number for zero or negative values
+# the number is expected in rax and returned in the low
+# half of xmm0
+.L__zni:
+	shl		$1,%rax
+	jnz		.L__zn_x		 ## if just a carry, then must be negative
+	movlpd	.L__real_ninf(%rip),%xmm0  # C99 specs -inf for +-0
+	ret
+.L__zn_x:
+	movlpd	.L__real_nan(%rip),%xmm0
+	ret
+
+
+
+
+	.data
+	.align	16
+
+.L__real_one:			.quad 0x03ff0000000000000	# 1.0
+				.quad 0x03ff0000000000000
+.L__real_two:			.quad 0x04000000000000000	# 2.0
+				.quad 0x04000000000000000
+.L__real_ninf:			.quad 0x0fff0000000000000	# -inf
+				.quad 0x0fff0000000000000
+.L__real_inf:			.quad 0x07ff0000000000000	# +inf
+				.quad 0x07ff0000000000000
+.L__real_nan:			.quad 0x07ff8000000000000	# NaN
+				.quad 0x07ff8000000000000
+
+.L__real_sign:			.quad 0x08000000000000000	# sign bit
+				.quad 0x08000000000000000
+.L__real_notsign:		.quad 0x07ffFFFFFFFFFFFFF	# ^sign bit
+				.quad 0x07ffFFFFFFFFFFFFF
+.L__real_threshold:		.quad 0x03F9EB85000000000	# .03
+				.quad 0x03F9EB85000000000
+.L__real_qnanbit:		.quad 0x00008000000000000	# quiet nan bit
+				.quad 0x00008000000000000
+.L__real_mant:			.quad 0x0000FFFFFFFFFFFFF	# mantissa bits
+				.quad 0x0000FFFFFFFFFFFFF
+.L__real_3f80000000000000:	.quad 0x03f80000000000000	# /* 0.0078125 = 1/128 */
+				.quad 0x03f80000000000000
+.L__mask_1023:			.quad 0x000000000000003ff	#
+				.quad 0x000000000000003ff
+.L__mask_040:			.quad 0x00000000000000040	#
+				.quad 0x00000000000000040
+.L__mask_001:			.quad 0x00000000000000001	#
+				.quad 0x00000000000000001
+
+.L__real_ca1:			.quad 0x03fb55555555554e6	# 8.33333333333317923934e-02
+				.quad 0x03fb55555555554e6
+.L__real_ca2:			.quad 0x03f89999999bac6d4	# 1.25000000037717509602e-02
+				.quad 0x03f89999999bac6d4
+.L__real_ca3:			.quad 0x03f62492307f1519f	# 2.23213998791944806202e-03
+				.quad 0x03f62492307f1519f
+.L__real_ca4:			.quad 0x03f3c8034c85dfff0	# 4.34887777707614552256e-04
+				.quad 0x03f3c8034c85dfff0
+
+.L__real_cb1:			.quad 0x03fb5555555555557	# 8.33333333333333593622e-02
+				.quad 0x03fb5555555555557
+.L__real_cb2:			.quad 0x03f89999999865ede	# 1.24999999978138668903e-02
+				.quad 0x03f89999999865ede
+.L__real_cb3:			.quad 0x03f6249423bd94741	# 2.23219810758559851206e-03
+				.quad 0x03f6249423bd94741
+.L__real_log2_lead:  		.quad 0x03fe62e42e0000000	# log2_lead	  6.93147122859954833984e-01
+				.quad 0x03fe62e42e0000000
+.L__real_log2_tail: 		.quad 0x03e6efa39ef35793c	# log2_tail	  5.76999904754328540596e-08
+				.quad 0x03e6efa39ef35793c
+
+.L__real_half:			.quad 0x03fe0000000000000	# 1/2
+				.quad 0x03fe0000000000000
+
+	.align	16
+
+.L__np_ln_lead_table:
+	.quad	0x0000000000000000 		# 0.00000000000000000000e+00
+	.quad	0x3f8fc0a800000000		# 1.55041813850402832031e-02
+	.quad	0x3f9f829800000000		# 3.07716131210327148438e-02
+	.quad	0x3fa7745800000000		# 4.58095073699951171875e-02
+	.quad	0x3faf0a3000000000		# 6.06245994567871093750e-02
+	.quad	0x3fb341d700000000		# 7.52233862876892089844e-02
+	.quad	0x3fb6f0d200000000		# 8.96121263504028320312e-02
+	.quad	0x3fba926d00000000		# 1.03796780109405517578e-01
+	.quad	0x3fbe270700000000		# 1.17783010005950927734e-01
+	.quad	0x3fc0d77e00000000		# 1.31576299667358398438e-01
+	.quad	0x3fc2955280000000		# 1.45181953907012939453e-01
+	.quad	0x3fc44d2b00000000		# 1.58604979515075683594e-01
+	.quad	0x3fc5ff3000000000		# 1.71850204467773437500e-01
+	.quad	0x3fc7ab8900000000		# 1.84922337532043457031e-01
+	.quad	0x3fc9525a80000000		# 1.97825729846954345703e-01
+	.quad	0x3fcaf3c900000000		# 2.10564732551574707031e-01
+	.quad	0x3fcc8ff780000000		# 2.23143517971038818359e-01
+	.quad	0x3fce270700000000		# 2.35566020011901855469e-01
+	.quad	0x3fcfb91800000000		# 2.47836112976074218750e-01
+	.quad	0x3fd0a324c0000000		# 2.59957492351531982422e-01
+	.quad	0x3fd1675c80000000		# 2.71933674812316894531e-01
+	.quad	0x3fd22941c0000000		# 2.83768117427825927734e-01
+	.quad	0x3fd2e8e280000000		# 2.95464158058166503906e-01
+	.quad	0x3fd3a64c40000000		# 3.07025015354156494141e-01
+	.quad	0x3fd4618bc0000000		# 3.18453729152679443359e-01
+	.quad	0x3fd51aad80000000		# 3.29753279685974121094e-01
+	.quad	0x3fd5d1bd80000000		# 3.40926527976989746094e-01
+	.quad	0x3fd686c800000000		# 3.51976394653320312500e-01
+	.quad	0x3fd739d7c0000000		# 3.62905442714691162109e-01
+	.quad	0x3fd7eaf800000000		# 3.73716354370117187500e-01
+	.quad	0x3fd89a3380000000		# 3.84411692619323730469e-01
+	.quad	0x3fd9479400000000		# 3.94993782043457031250e-01
+	.quad	0x3fd9f323c0000000		# 4.05465066432952880859e-01
+	.quad	0x3fda9cec80000000		# 4.15827870368957519531e-01
+	.quad	0x3fdb44f740000000		# 4.26084339618682861328e-01
+	.quad	0x3fdbeb4d80000000		# 4.36236739158630371094e-01
+	.quad	0x3fdc8ff7c0000000		# 4.46287095546722412109e-01
+	.quad	0x3fdd32fe40000000		# 4.56237375736236572266e-01
+	.quad	0x3fddd46a00000000		# 4.66089725494384765625e-01
+	.quad	0x3fde744240000000		# 4.75845873355865478516e-01
+	.quad	0x3fdf128f40000000		# 4.85507786273956298828e-01
+	.quad	0x3fdfaf5880000000		# 4.95077252388000488281e-01
+	.quad	0x3fe02552a0000000		# 5.04556000232696533203e-01
+	.quad	0x3fe0723e40000000		# 5.13945698738098144531e-01
+	.quad	0x3fe0be72e0000000		# 5.23248136043548583984e-01
+	.quad	0x3fe109f380000000		# 5.32464742660522460938e-01
+	.quad	0x3fe154c3c0000000		# 5.41597247123718261719e-01
+	.quad	0x3fe19ee6a0000000		# 5.50647079944610595703e-01
+	.quad	0x3fe1e85f40000000		# 5.59615731239318847656e-01
+	.quad	0x3fe23130c0000000		# 5.68504691123962402344e-01
+	.quad	0x3fe2795e00000000		# 5.77315330505371093750e-01
+	.quad	0x3fe2c0e9e0000000		# 5.86049020290374755859e-01
+	.quad	0x3fe307d720000000		# 5.94707071781158447266e-01
+	.quad	0x3fe34e2880000000		# 6.03290796279907226562e-01
+	.quad	0x3fe393e0c0000000		# 6.11801505088806152344e-01
+	.quad	0x3fe3d90260000000		# 6.20240390300750732422e-01
+	.quad	0x3fe41d8fe0000000		# 6.28608644008636474609e-01
+	.quad	0x3fe4618bc0000000		# 6.36907458305358886719e-01
+	.quad	0x3fe4a4f840000000		# 6.45137906074523925781e-01
+	.quad	0x3fe4e7d800000000		# 6.53301239013671875000e-01
+	.quad	0x3fe52a2d20000000		# 6.61398470401763916016e-01
+	.quad	0x3fe56bf9c0000000		# 6.69430613517761230469e-01
+	.quad	0x3fe5ad4040000000		# 6.77398800849914550781e-01
+	.quad	0x3fe5ee02a0000000		# 6.85303986072540283203e-01
+	.quad	0x3fe62e42e0000000		# 6.93147122859954833984e-01
+	.quad 0					# for alignment
+
+.L__np_ln_tail_table:
+	.quad	0x00000000000000000 # 0	; 0.00000000000000000000e+00
+	.quad	0x03e361f807c79f3db		# 5.15092497094772879206e-09
+	.quad	0x03e6873c1980267c8		# 4.55457209735272790188e-08
+	.quad	0x03e5ec65b9f88c69e		# 2.86612990859791781788e-08
+	.quad	0x03e58022c54cc2f99		# 2.23596477332056055352e-08
+	.quad	0x03e62c37a3a125330		# 3.49498983167142274770e-08
+	.quad	0x03e615cad69737c93		# 3.23392843005887000414e-08
+	.quad	0x03e4d256ab1b285e9		# 1.35722380472479366661e-08
+	.quad	0x03e5b8abcb97a7aa2		# 2.56504325268044191098e-08
+	.quad	0x03e6f34239659a5dc		# 5.81213608741512136843e-08
+	.quad	0x03e6e07fd48d30177		# 5.59374849578288093334e-08
+	.quad	0x03e6b32df4799f4f6		# 5.06615629004996189970e-08
+	.quad	0x03e6c29e4f4f21cf8		# 5.24588857848400955725e-08
+	.quad	0x03e1086c848df1b59		# 9.61968535632653505972e-10
+	.quad	0x03e4cf456b4764130		# 1.34829655346594463137e-08
+	.quad	0x03e63a02ffcb63398		# 3.65557749306383026498e-08
+	.quad	0x03e61e6a6886b0976		# 3.33431709374069198903e-08
+	.quad	0x03e6b8abcb97a7aa2		# 5.13008650536088382197e-08
+	.quad	0x03e6b578f8aa35552		# 5.09285070380306053751e-08
+	.quad	0x03e6139c871afb9fc		# 3.20853940845502057341e-08
+	.quad	0x03e65d5d30701ce64		# 4.06713248643004200446e-08
+	.quad	0x03e6de7bcb2d12142		# 5.57028186706125221168e-08
+	.quad	0x03e6d708e984e1664		# 5.48356693724804282546e-08
+	.quad	0x03e556945e9c72f36		# 1.99407553679345001938e-08
+	.quad	0x03e20e2f613e85bda		# 1.96585517245087232086e-09
+	.quad	0x03e3cb7e0b42724f6		# 6.68649386072067321503e-09
+	.quad	0x03e6fac04e52846c7		# 5.89936034642113390002e-08
+	.quad	0x03e5e9b14aec442be		# 2.85038578721554472484e-08
+	.quad	0x03e6b5de8034e7126		# 5.09746772910284482606e-08
+	.quad	0x03e6dc157e1b259d3		# 5.54234668933210171467e-08
+	.quad	0x03e3b05096ad69c62		# 6.29100830926604004874e-09
+	.quad	0x03e5c2116faba4cdd		# 2.61974119468563937716e-08
+	.quad	0x03e665fcc25f95b47		# 4.16752115011186398935e-08
+	.quad	0x03e5a9a08498d4850		# 2.47747534460820790327e-08
+	.quad	0x03e6de647b1465f77		# 5.56922172017964209793e-08
+	.quad	0x03e5da71b7bf7861d		# 2.76162876992552906035e-08
+	.quad	0x03e3e6a6886b09760		# 7.08169709942321478061e-09
+	.quad	0x03e6f0075eab0ef64		# 5.77453510221151779025e-08
+	.quad	0x03e33071282fb989b		# 4.43021445893361960146e-09
+	.quad	0x03e60eb43c3f1bed2		# 3.15140984357495864573e-08
+	.quad	0x03e5faf06ecb35c84		# 2.95077445089736670973e-08
+	.quad	0x03e4ef1e63db35f68		# 1.44098510263167149349e-08
+	.quad	0x03e469743fb1a71a5		# 1.05196987538551827693e-08
+	.quad	0x03e6c1cdf404e5796		# 5.23641361722697546261e-08
+	.quad	0x03e4094aa0ada625e		# 7.72099925253243069458e-09
+	.quad	0x03e6e2d4c96fde3ec		# 5.62089493829364197156e-08
+	.quad	0x03e62f4d5e9a98f34		# 3.53090261098577946927e-08
+	.quad	0x03e6467c96ecc5cbe		# 3.80080516835568242269e-08
+	.quad	0x03e6e7040d03dec5a		# 5.66961038386146408282e-08
+	.quad	0x03e67bebf4282de36		# 4.42287063097349852717e-08
+	.quad	0x03e6289b11aeb783f		# 3.45294525105681104660e-08
+	.quad	0x03e5a891d1772f538		# 2.47132034530447431509e-08
+	.quad	0x03e634f10be1fb591		# 3.59655343422487209774e-08
+	.quad	0x03e6d9ce1d316eb93		# 5.51581770357780862071e-08
+	.quad	0x03e63562a19a9c442		# 3.60171867511861372793e-08
+	.quad	0x03e54e2adf548084c		# 1.94511067964296180547e-08
+	.quad	0x03e508ce55cc8c97a		# 1.54137376631349347838e-08
+	.quad	0x03e30e2f613e85bda		# 3.93171034490174464173e-09
+	.quad	0x03e6db03ebb0227bf		# 5.52990607758839766440e-08
+	.quad	0x03e61b75bb09cb098		# 3.29990737637586136511e-08
+	.quad	0x03e496f16abb9df22		# 1.18436010922446096216e-08
+	.quad	0x03e65b3f399411c62		# 4.04248680368301346709e-08
+	.quad	0x03e586b3e59f65355		# 2.27418915900284316293e-08
+	.quad	0x03e52482ceae1ac12		# 1.70263791333409206020e-08
+	.quad	0x03e6efa39ef35793c		# 5.76999904754328540596e-08
+	.quad 0					# for alignment
+
+
diff --git a/src/gas/vrd2log10.S b/src/gas/vrd2log10.S
new file mode 100644
index 0000000..46cb2ad
--- /dev/null
+++ b/src/gas/vrd2log10.S
@@ -0,0 +1,628 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrd2log10.s
+#
+# An implementation of the log10 libm function.
+#
+# Prototype:
+#
+#     __m128d __vrd2_log10(__m128d x);
+#
+#   Computes the natural log10 of x.
+#   Returns proper C99 values, but may not raise status flags properly.
+#   Less than 1 ulp of error.  Runs 120-130 cycles for valid inputs.
+#
+#
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+
+# define local variable storage offsets
+.equ	p_x,0			# temporary for error checking operation
+.equ	p_idx,0x010		# index storage
+
+.equ	stack_size,0x028
+
+
+
+    .text
+    .align 16
+    .p2align 4,,15
+.globl __vrd2_log10
+    .type   __vrd2_log10,@function
+__vrd2_log10:
+	sub		$stack_size,%rsp
+
+	movdqa	%xmm0,p_x(%rsp)	# save the input values
+
+
+#      /* Store the exponent of x in xexp and put
+#         f into the range [0.5,1) */
+
+#
+# compute the index into the log10 tables
+#
+	pxor	%xmm1,%xmm1
+	movdqa	%xmm0,%xmm3
+	psrlq	$52,%xmm3
+	psubq	.L__mask_1023(%rip),%xmm3
+	packssdw	%xmm1,%xmm3
+	cvtdq2pd	%xmm3,%xmm6			# xexp
+	movdqa	%xmm0,%xmm2
+	xor		%rax,%rax
+	subpd	.L__real_one(%rip),%xmm2
+
+	movdqa	%xmm0,%xmm3
+	andpd	.L__real_notsign(%rip),%xmm2
+	pand	.L__real_mant(%rip),%xmm3
+	movdqa	%xmm3,%xmm4
+	movapd	.L__real_half(%rip),%xmm5							# .5
+
+	cmppd	$1,.L__real_threshold(%rip),%xmm2
+	movmskpd	%xmm2,%r10d
+	cmp		$3,%r10d
+	jz		.Lall_nearone
+
+#/* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+	psrlq	$45,%xmm3
+	movdqa	%xmm3,%xmm2
+	psrlq	$1,%xmm3
+	paddq	.L__mask_040(%rip),%xmm3
+	pand	.L__mask_001(%rip),%xmm2
+	paddq	%xmm2,%xmm3
+
+	packssdw	%xmm1,%xmm3
+	cvtdq2pd	%xmm3,%xmm1
+	xor		%rcx,%rcx
+	movq	 %xmm3,p_idx(%rsp)
+
+# reduce and get u
+	por		.L__real_half(%rip),%xmm4
+	movdqa	%xmm4,%xmm2
+
+
+	mulpd	.L__real_3f80000000000000(%rip),%xmm1		# f1 = index/128
+
+
+	lea	.L__np_ln_lead_table(%rip),%rdx
+	mov	p_idx(%rsp),%eax
+
+	subpd	%xmm1,%xmm2				# f2 = f - f1
+	mulpd	%xmm2,%xmm5
+	addpd	%xmm5,%xmm1
+
+	divpd	%xmm1,%xmm2				# u
+
+# do error checking here for scheduling.  Saves a bunch of cycles as
+# compared to doing this at the start of the routine.
+##  if NaN or inf
+	movapd	%xmm0,%xmm3
+	andpd	.L__real_inf(%rip),%xmm3
+	cmppd	$0,.L__real_inf(%rip),%xmm3
+	movmskpd	%xmm3,%r8d
+	xorpd	%xmm1,%xmm1
+
+	cmppd	$2,%xmm1,%xmm0
+	movmskpd	%xmm0,%r9d
+
+# get z
+	movlpd	 -512(%rdx,%rax,8),%xmm0		# z1
+	mov		p_idx+4(%rsp),%ecx
+	movhpd	 -512(%rdx,%rcx,8),%xmm0		# z1
+# solve for ln(1+u)
+	movapd	%xmm2,%xmm1				# u
+	mulpd	%xmm2,%xmm2				# u^2
+	movapd	%xmm2,%xmm5
+	movapd	.L__real_cb3(%rip),%xmm3
+	mulpd	%xmm2,%xmm3				#Cu2
+	mulpd	%xmm1,%xmm5				# u^3
+	addpd	.L__real_cb2(%rip),%xmm3 		#B+Cu2
+
+	mulpd	%xmm5,%xmm2				# u^5
+	movapd	.L__real_log2_lead(%rip),%xmm4
+
+	mulpd	.L__real_cb1(%rip),%xmm5 		#Au3
+	addpd	%xmm5,%xmm1				# u+Au3
+	mulpd	%xmm3,%xmm2				# u5(B+Cu2)
+
+	addpd	%xmm2,%xmm1				# poly
+# recombine
+	mulpd	%xmm6,%xmm4				# xexp * log2_lead
+	addpd	%xmm4,%xmm0				#r1
+	movapd  %xmm0,%xmm2
+	lea		.L__np_ln_tail_table(%rip),%rdx
+	movlpd	 -512(%rdx,%rax,8),%xmm4		#z2	+=q
+	movhpd	 -512(%rdx,%rcx,8),%xmm4		#z2	+=q
+	addpd	%xmm4,%xmm1
+
+	mulpd	.L__real_log2_tail(%rip),%xmm6
+
+	addpd	%xmm6,%xmm1				#r2
+
+#   loge to log10
+	movapd  %xmm1,%xmm3
+	mulpd 	.L__real_log10e_tail(%rip),%xmm1
+	mulpd 	.L__real_log10e_tail(%rip),%xmm0
+	addpd   %xmm1,%xmm0
+	mulpd 	.L__real_log10e_lead(%rip),%xmm3
+	addpd 	%xmm3,%xmm0
+	mulpd 	.L__real_log10e_lead(%rip),%xmm2
+# check for nans/infs
+	test	$3,%r8d
+	addpd	%xmm2,%xmm0
+
+	jnz		.L__log_naninf
+.L__vlog1:
+# check for negative numbers or zero
+	test		$3,%r9d
+	jnz		.L__z_or_n
+
+.L__finish:
+# see if we have a near one value
+	test		 $3,%r10d
+	jnz		.L__near_one
+.L__finishn1:
+	add		$stack_size,%rsp
+	ret
+
+	.align	16
+.Lall_nearone:
+# saves 10 cycles
+#      r = x - 1.0;
+	movapd	.L__real_two(%rip),%xmm2
+	subpd	.L__real_one(%rip),%xmm0	   # r
+#      u          = r / (2.0 + r);
+	addpd	%xmm0,%xmm2
+	movapd	%xmm0,%xmm1
+	divpd	%xmm2,%xmm1			# u
+	movapd	.L__real_ca4(%rip),%xmm4	  #D
+	movapd	.L__real_ca3(%rip),%xmm5	  #C
+#      correction = r * u;
+	movapd	%xmm0,%xmm6
+	mulpd	%xmm1,%xmm6		# correction
+#      u          = u + u;
+	addpd	%xmm1,%xmm1		#u
+	movapd	%xmm1,%xmm2
+	mulpd	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulpd	%xmm1,%xmm5		# Cu
+	movapd	%xmm1,%xmm3
+	mulpd	%xmm2,%xmm3		# u^3
+	mulpd	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulpd	%xmm3,%xmm4		#Du^3
+
+	addpd	.L__real_ca1(%rip),%xmm2	# +A
+	movapd	%xmm3,%xmm1
+	mulpd	%xmm1,%xmm1		# u^6
+	addpd	%xmm4,%xmm5		#Cu+Du3
+#	subsd	%xmm6,%xmm0		; -correction
+
+	mulpd	%xmm3,%xmm2		#u3(A+Bu2)
+	mulpd	%xmm5,%xmm1		#u6(Cu+Du3)
+	addpd	%xmm1,%xmm2
+	subpd	%xmm6,%xmm2		# -correction
+
+#	loge to log10
+	movapd 	%xmm0,%xmm3		#r1 = r
+	pand	.L__mask_lower(%rip),%xmm3
+	subpd	%xmm3,%xmm0
+	addpd 	%xmm0,%xmm2		#r2 = r2 + (r - r1);
+
+	movapd 	%xmm3,%xmm0
+	movapd	%xmm2,%xmm1
+
+	mulpd 	.L__real_log10e_tail(%rip),%xmm2
+	mulpd 	.L__real_log10e_tail(%rip),%xmm0
+	mulpd 	.L__real_log10e_lead(%rip),%xmm1
+	mulpd 	.L__real_log10e_lead(%rip),%xmm3
+	addpd 	%xmm2,%xmm0
+	addpd 	%xmm1,%xmm0
+	addpd	%xmm3,%xmm0
+
+#      return r + r2;
+#	addpd	%xmm2,%xmm0
+	jmp		.L__finishn1
+
+	.align	16
+.L__near_one:
+	test	$1,%r10d
+	jz		.L__lnn12
+
+#	movapd	%xmm0,%xmm6		; save the inputs
+	movlpd	p_x(%rsp),%xmm0
+	call	.L__ln1
+#	shufpd	xmm0,$2,%xmm6
+
+.L__lnn12:
+	test	$2,%r10d		# second number?
+	jz		.L__lnn1e
+	movlpd	%xmm0,p_x(%rsp)
+	movlpd	p_x+8(%rsp),%xmm0
+	call	.L__ln1
+	movlpd	%xmm0,p_x+8(%rsp)
+	movapd	p_x(%rsp),%xmm0
+#	shufpd	xmm6,$0,%xmm0
+#	movapd	%xmm6,%xmm0
+
+.L__lnn1e:
+	jmp		.L__finishn1
+
+.L__ln1:
+# saves 10 cycles
+#      r = x - 1.0;
+	movlpd	.L__real_two(%rip),%xmm2
+	subsd	.L__real_one(%rip),%xmm0	# r
+#      u          = r / (2.0 + r);
+	addsd	%xmm0,%xmm2
+	movsd	%xmm0,%xmm1
+	divsd	%xmm2,%xmm1			# u
+	movlpd	.L__real_ca4(%rip),%xmm4	#D
+	movlpd	.L__real_ca3(%rip),%xmm5	#C
+#      correction = r * u;
+	movsd	%xmm0,%xmm6
+	mulsd	%xmm1,%xmm6		# correction
+#      u          = u + u;
+	addsd	%xmm1,%xmm1		#u
+	movsd	%xmm1,%xmm2
+	mulsd	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulsd	%xmm1,%xmm5		# Cu
+	movsd	%xmm1,%xmm3
+	mulsd	%xmm2,%xmm3		# u^3
+	mulsd	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulsd	%xmm3,%xmm4		#Du^3
+
+	addsd	.L__real_ca1(%rip),%xmm2	# +A
+	movsd	%xmm3,%xmm1
+	mulsd	%xmm1,%xmm1		# u^6
+	addsd	%xmm4,%xmm5		#Cu+Du3
+#	subsd	%xmm6,%xmm0		; -correction
+
+	mulsd	%xmm3,%xmm2		#u3(A+Bu2)
+	mulsd	%xmm5,%xmm1		#u6(Cu+Du3)
+	addsd	%xmm1,%xmm2
+	subsd	%xmm6,%xmm2		# -correction
+
+#	loge to log10
+	movsd 	%xmm0,%xmm3		#r1 = r
+	pand	.L__mask_lower(%rip),%xmm3
+	subsd	%xmm3,%xmm0
+	addsd 	%xmm0,%xmm2		#r2 = r2 + (r - r1);
+
+	movsd 	%xmm3,%xmm0
+	movsd	%xmm2,%xmm1
+
+	mulsd 	.L__real_log10e_tail(%rip),%xmm2
+	mulsd 	.L__real_log10e_tail(%rip),%xmm0
+	mulsd 	.L__real_log10e_lead(%rip),%xmm1
+	mulsd 	.L__real_log10e_lead(%rip),%xmm3
+	addsd 	%xmm2,%xmm0
+	addsd 	%xmm1,%xmm0
+	addsd	%xmm3,%xmm0
+
+
+
+#      return r + r2;
+#	addsd	%xmm2,%xmm0
+	ret
+
+	.align	16
+
+# at least one of the numbers was a nan or infinity
+.L__log_naninf:
+	test		$1,%r8d		# first number?
+	jz		.L__lninf2
+
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x(%rsp),%rdx
+	movlpd	p_x(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$2,%xmm1,%xmm0
+
+.L__lninf2:
+	test		$2,%r8d		# second number?
+	jz		.L__lninfe
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov	p_x+8(%rsp),%rdx
+	movlpd	p_x+8(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$0,%xmm0,%xmm1
+	movapd	%xmm1,%xmm0
+
+.L__lninfe:
+
+	cmp		$3,%r8d		# both numbers?
+	jz		.L__finish	# return early if so
+	jmp		.L__vlog1	# continue processing if not
+
+# a subroutine to treat one number for nan/infinity
+# the number is expected in rdx and returned in the low
+# half of xmm0
+.L__lni:
+	mov		$0x0000FFFFFFFFFFFFF,%rax
+	test	%rax,%rdx
+	jnz		.L__lnan	# jump if mantissa not zero, so it's a NaN
+# inf
+	rcl		$1,%rdx
+	jnc		.L__lne2	# log(+inf) = inf
+# negative x
+	movlpd	.L__real_nan(%rip),%xmm0
+	ret
+
+#NaN
+.L__lnan:
+	mov		$0x00008000000000000,%rax	# convert to quiet
+	or		%rax,%rdx
+.L__lne:
+	movd	%rdx,%xmm0
+.L__lne2:
+	ret
+
+	.align	16
+
+# at least one of the numbers was a zero, a negative number, or both.
+.L__z_or_n:
+	test		$1,%r9d		# first number?
+	jz		.L__zn2
+
+#	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x(%rsp),%rax
+	call	.L__zni
+#	shufpd	$2,%xmm1,%xmm0
+
+.L__zn2:
+	test		$2,%r9d		# second number?
+	jz		.L__zne
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x+8(%rsp),%rax
+	call	.L__zni
+	shufpd	$0,%xmm0,%xmm1
+	movapd	%xmm1,%xmm0
+
+.L__zne:
+	jmp		.L__finish
+
+# a subroutine to treat one number for zero or negative values
+# the number is expected in rax and returned in the low
+# half of xmm0
+.L__zni:
+	shl		$1,%rax
+	jnz		.L__zn_x		 ## if just a carry, then must be negative
+	movlpd	.L__real_ninf(%rip),%xmm0  # C99 specs -inf for +-0
+	ret
+.L__zn_x:
+	movlpd	.L__real_nan(%rip),%xmm0
+	ret
+
+
+
+
+	.data
+	.align	16
+
+.L__real_one:			.quad 0x03ff0000000000000	# 1.0
+				.quad 0x03ff0000000000000
+.L__real_two:			.quad 0x04000000000000000	# 2.0
+				.quad 0x04000000000000000
+.L__real_ninf:			.quad 0x0fff0000000000000	# -inf
+				.quad 0x0fff0000000000000
+.L__real_inf:			.quad 0x07ff0000000000000	# +inf
+				.quad 0x07ff0000000000000
+.L__real_nan:			.quad 0x07ff8000000000000	# NaN
+				.quad 0x07ff8000000000000
+
+.L__real_sign:			.quad 0x08000000000000000	# sign bit
+				.quad 0x08000000000000000
+.L__real_notsign:		.quad 0x07ffFFFFFFFFFFFFF	# ^sign bit
+				.quad 0x07ffFFFFFFFFFFFFF
+.L__real_threshold:		.quad 0x03FB082C000000000	# .064495086669921875 Threshold
+				.quad 0x03FB082C000000000
+.L__real_qnanbit:		.quad 0x00008000000000000	# quiet nan bit
+				.quad 0x00008000000000000
+.L__real_mant:			.quad 0x0000FFFFFFFFFFFFF	# mantissa bits
+				.quad 0x0000FFFFFFFFFFFFF
+.L__real_3f80000000000000:	.quad 0x03f80000000000000	# /* 0.0078125 = 1/128 */
+				.quad 0x03f80000000000000
+.L__mask_1023:			.quad 0x000000000000003ff	#
+				.quad 0x000000000000003ff
+.L__mask_040:			.quad 0x00000000000000040	#
+				.quad 0x00000000000000040
+.L__mask_001:			.quad 0x00000000000000001	#
+				.quad 0x00000000000000001
+
+.L__real_ca1:			.quad 0x03fb55555555554e6	# 8.33333333333317923934e-02
+				.quad 0x03fb55555555554e6
+.L__real_ca2:			.quad 0x03f89999999bac6d4	# 1.25000000037717509602e-02
+				.quad 0x03f89999999bac6d4
+.L__real_ca3:			.quad 0x03f62492307f1519f	# 2.23213998791944806202e-03
+				.quad 0x03f62492307f1519f
+.L__real_ca4:			.quad 0x03f3c8034c85dfff0	# 4.34887777707614552256e-04
+				.quad 0x03f3c8034c85dfff0
+
+.L__real_cb1:			.quad 0x03fb5555555555557	# 8.33333333333333593622e-02
+				.quad 0x03fb5555555555557
+.L__real_cb2:			.quad 0x03f89999999865ede	# 1.24999999978138668903e-02
+				.quad 0x03f89999999865ede
+.L__real_cb3:			.quad 0x03f6249423bd94741	# 2.23219810758559851206e-03
+				.quad 0x03f6249423bd94741
+.L__real_log2_lead:  		.quad 0x03fe62e42e0000000	# log2_lead	  6.93147122859954833984e-01
+				.quad 0x03fe62e42e0000000
+.L__real_log2_tail: 		.quad 0x03e6efa39ef35793c	# log2_tail	  5.76999904754328540596e-08
+				.quad 0x03e6efa39ef35793c
+
+.L__real_half:			.quad 0x03fe0000000000000	# 1/2
+				.quad 0x03fe0000000000000
+
+.L__real_log10e_lead:	.quad 0x03fdbcb7800000000	# log10e_lead 4.34293746948242187500e-01
+				.quad 0x03fdbcb7800000000
+.L__real_log10e_tail:	.quad 0x03ea8a93728719535	# log10e_tail 7.3495500964015109100644e-7
+				.quad 0x03ea8a93728719535
+
+.L__mask_lower:			.quad 0x0ffffffff00000000
+				.quad 0x0ffffffff00000000
+
+	.align	16
+
+.L__np_ln_lead_table:
+	.quad	0x0000000000000000 		# 0.00000000000000000000e+00
+	.quad	0x3f8fc0a800000000		# 1.55041813850402832031e-02
+	.quad	0x3f9f829800000000		# 3.07716131210327148438e-02
+	.quad	0x3fa7745800000000		# 4.58095073699951171875e-02
+	.quad	0x3faf0a3000000000		# 6.06245994567871093750e-02
+	.quad	0x3fb341d700000000		# 7.52233862876892089844e-02
+	.quad	0x3fb6f0d200000000		# 8.96121263504028320312e-02
+	.quad	0x3fba926d00000000		# 1.03796780109405517578e-01
+	.quad	0x3fbe270700000000		# 1.17783010005950927734e-01
+	.quad	0x3fc0d77e00000000		# 1.31576299667358398438e-01
+	.quad	0x3fc2955280000000		# 1.45181953907012939453e-01
+	.quad	0x3fc44d2b00000000		# 1.58604979515075683594e-01
+	.quad	0x3fc5ff3000000000		# 1.71850204467773437500e-01
+	.quad	0x3fc7ab8900000000		# 1.84922337532043457031e-01
+	.quad	0x3fc9525a80000000		# 1.97825729846954345703e-01
+	.quad	0x3fcaf3c900000000		# 2.10564732551574707031e-01
+	.quad	0x3fcc8ff780000000		# 2.23143517971038818359e-01
+	.quad	0x3fce270700000000		# 2.35566020011901855469e-01
+	.quad	0x3fcfb91800000000		# 2.47836112976074218750e-01
+	.quad	0x3fd0a324c0000000		# 2.59957492351531982422e-01
+	.quad	0x3fd1675c80000000		# 2.71933674812316894531e-01
+	.quad	0x3fd22941c0000000		# 2.83768117427825927734e-01
+	.quad	0x3fd2e8e280000000		# 2.95464158058166503906e-01
+	.quad	0x3fd3a64c40000000		# 3.07025015354156494141e-01
+	.quad	0x3fd4618bc0000000		# 3.18453729152679443359e-01
+	.quad	0x3fd51aad80000000		# 3.29753279685974121094e-01
+	.quad	0x3fd5d1bd80000000		# 3.40926527976989746094e-01
+	.quad	0x3fd686c800000000		# 3.51976394653320312500e-01
+	.quad	0x3fd739d7c0000000		# 3.62905442714691162109e-01
+	.quad	0x3fd7eaf800000000		# 3.73716354370117187500e-01
+	.quad	0x3fd89a3380000000		# 3.84411692619323730469e-01
+	.quad	0x3fd9479400000000		# 3.94993782043457031250e-01
+	.quad	0x3fd9f323c0000000		# 4.05465066432952880859e-01
+	.quad	0x3fda9cec80000000		# 4.15827870368957519531e-01
+	.quad	0x3fdb44f740000000		# 4.26084339618682861328e-01
+	.quad	0x3fdbeb4d80000000		# 4.36236739158630371094e-01
+	.quad	0x3fdc8ff7c0000000		# 4.46287095546722412109e-01
+	.quad	0x3fdd32fe40000000		# 4.56237375736236572266e-01
+	.quad	0x3fddd46a00000000		# 4.66089725494384765625e-01
+	.quad	0x3fde744240000000		# 4.75845873355865478516e-01
+	.quad	0x3fdf128f40000000		# 4.85507786273956298828e-01
+	.quad	0x3fdfaf5880000000		# 4.95077252388000488281e-01
+	.quad	0x3fe02552a0000000		# 5.04556000232696533203e-01
+	.quad	0x3fe0723e40000000		# 5.13945698738098144531e-01
+	.quad	0x3fe0be72e0000000		# 5.23248136043548583984e-01
+	.quad	0x3fe109f380000000		# 5.32464742660522460938e-01
+	.quad	0x3fe154c3c0000000		# 5.41597247123718261719e-01
+	.quad	0x3fe19ee6a0000000		# 5.50647079944610595703e-01
+	.quad	0x3fe1e85f40000000		# 5.59615731239318847656e-01
+	.quad	0x3fe23130c0000000		# 5.68504691123962402344e-01
+	.quad	0x3fe2795e00000000		# 5.77315330505371093750e-01
+	.quad	0x3fe2c0e9e0000000		# 5.86049020290374755859e-01
+	.quad	0x3fe307d720000000		# 5.94707071781158447266e-01
+	.quad	0x3fe34e2880000000		# 6.03290796279907226562e-01
+	.quad	0x3fe393e0c0000000		# 6.11801505088806152344e-01
+	.quad	0x3fe3d90260000000		# 6.20240390300750732422e-01
+	.quad	0x3fe41d8fe0000000		# 6.28608644008636474609e-01
+	.quad	0x3fe4618bc0000000		# 6.36907458305358886719e-01
+	.quad	0x3fe4a4f840000000		# 6.45137906074523925781e-01
+	.quad	0x3fe4e7d800000000		# 6.53301239013671875000e-01
+	.quad	0x3fe52a2d20000000		# 6.61398470401763916016e-01
+	.quad	0x3fe56bf9c0000000		# 6.69430613517761230469e-01
+	.quad	0x3fe5ad4040000000		# 6.77398800849914550781e-01
+	.quad	0x3fe5ee02a0000000		# 6.85303986072540283203e-01
+	.quad	0x3fe62e42e0000000		# 6.93147122859954833984e-01
+	.quad 0					# for alignment
+
+.L__np_ln_tail_table:
+	.quad	0x00000000000000000 # 0	; 0.00000000000000000000e+00
+	.quad	0x03e361f807c79f3db		# 5.15092497094772879206e-09
+	.quad	0x03e6873c1980267c8		# 4.55457209735272790188e-08
+	.quad	0x03e5ec65b9f88c69e		# 2.86612990859791781788e-08
+	.quad	0x03e58022c54cc2f99		# 2.23596477332056055352e-08
+	.quad	0x03e62c37a3a125330		# 3.49498983167142274770e-08
+	.quad	0x03e615cad69737c93		# 3.23392843005887000414e-08
+	.quad	0x03e4d256ab1b285e9		# 1.35722380472479366661e-08
+	.quad	0x03e5b8abcb97a7aa2		# 2.56504325268044191098e-08
+	.quad	0x03e6f34239659a5dc		# 5.81213608741512136843e-08
+	.quad	0x03e6e07fd48d30177		# 5.59374849578288093334e-08
+	.quad	0x03e6b32df4799f4f6		# 5.06615629004996189970e-08
+	.quad	0x03e6c29e4f4f21cf8		# 5.24588857848400955725e-08
+	.quad	0x03e1086c848df1b59		# 9.61968535632653505972e-10
+	.quad	0x03e4cf456b4764130		# 1.34829655346594463137e-08
+	.quad	0x03e63a02ffcb63398		# 3.65557749306383026498e-08
+	.quad	0x03e61e6a6886b0976		# 3.33431709374069198903e-08
+	.quad	0x03e6b8abcb97a7aa2		# 5.13008650536088382197e-08
+	.quad	0x03e6b578f8aa35552		# 5.09285070380306053751e-08
+	.quad	0x03e6139c871afb9fc		# 3.20853940845502057341e-08
+	.quad	0x03e65d5d30701ce64		# 4.06713248643004200446e-08
+	.quad	0x03e6de7bcb2d12142		# 5.57028186706125221168e-08
+	.quad	0x03e6d708e984e1664		# 5.48356693724804282546e-08
+	.quad	0x03e556945e9c72f36		# 1.99407553679345001938e-08
+	.quad	0x03e20e2f613e85bda		# 1.96585517245087232086e-09
+	.quad	0x03e3cb7e0b42724f6		# 6.68649386072067321503e-09
+	.quad	0x03e6fac04e52846c7		# 5.89936034642113390002e-08
+	.quad	0x03e5e9b14aec442be		# 2.85038578721554472484e-08
+	.quad	0x03e6b5de8034e7126		# 5.09746772910284482606e-08
+	.quad	0x03e6dc157e1b259d3		# 5.54234668933210171467e-08
+	.quad	0x03e3b05096ad69c62		# 6.29100830926604004874e-09
+	.quad	0x03e5c2116faba4cdd		# 2.61974119468563937716e-08
+	.quad	0x03e665fcc25f95b47		# 4.16752115011186398935e-08
+	.quad	0x03e5a9a08498d4850		# 2.47747534460820790327e-08
+	.quad	0x03e6de647b1465f77		# 5.56922172017964209793e-08
+	.quad	0x03e5da71b7bf7861d		# 2.76162876992552906035e-08
+	.quad	0x03e3e6a6886b09760		# 7.08169709942321478061e-09
+	.quad	0x03e6f0075eab0ef64		# 5.77453510221151779025e-08
+	.quad	0x03e33071282fb989b		# 4.43021445893361960146e-09
+	.quad	0x03e60eb43c3f1bed2		# 3.15140984357495864573e-08
+	.quad	0x03e5faf06ecb35c84		# 2.95077445089736670973e-08
+	.quad	0x03e4ef1e63db35f68		# 1.44098510263167149349e-08
+	.quad	0x03e469743fb1a71a5		# 1.05196987538551827693e-08
+	.quad	0x03e6c1cdf404e5796		# 5.23641361722697546261e-08
+	.quad	0x03e4094aa0ada625e		# 7.72099925253243069458e-09
+	.quad	0x03e6e2d4c96fde3ec		# 5.62089493829364197156e-08
+	.quad	0x03e62f4d5e9a98f34		# 3.53090261098577946927e-08
+	.quad	0x03e6467c96ecc5cbe		# 3.80080516835568242269e-08
+	.quad	0x03e6e7040d03dec5a		# 5.66961038386146408282e-08
+	.quad	0x03e67bebf4282de36		# 4.42287063097349852717e-08
+	.quad	0x03e6289b11aeb783f		# 3.45294525105681104660e-08
+	.quad	0x03e5a891d1772f538		# 2.47132034530447431509e-08
+	.quad	0x03e634f10be1fb591		# 3.59655343422487209774e-08
+	.quad	0x03e6d9ce1d316eb93		# 5.51581770357780862071e-08
+	.quad	0x03e63562a19a9c442		# 3.60171867511861372793e-08
+	.quad	0x03e54e2adf548084c		# 1.94511067964296180547e-08
+	.quad	0x03e508ce55cc8c97a		# 1.54137376631349347838e-08
+	.quad	0x03e30e2f613e85bda		# 3.93171034490174464173e-09
+	.quad	0x03e6db03ebb0227bf		# 5.52990607758839766440e-08
+	.quad	0x03e61b75bb09cb098		# 3.29990737637586136511e-08
+	.quad	0x03e496f16abb9df22		# 1.18436010922446096216e-08
+	.quad	0x03e65b3f399411c62		# 4.04248680368301346709e-08
+	.quad	0x03e586b3e59f65355		# 2.27418915900284316293e-08
+	.quad	0x03e52482ceae1ac12		# 1.70263791333409206020e-08
+	.quad	0x03e6efa39ef35793c		# 5.76999904754328540596e-08
+	.quad 0					# for alignment
+
+
diff --git a/src/gas/vrd2log2.S b/src/gas/vrd2log2.S
new file mode 100644
index 0000000..92fe290
--- /dev/null
+++ b/src/gas/vrd2log2.S
@@ -0,0 +1,621 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrd2log.s
+#
+# An implementation of the log libm function.
+#
+# Prototype:
+#
+#     __m128d __vrd2_log2(__m128d x);
+#
+#   Computes the  log2 of x.
+#   Returns proper C99 values, but may not raise status flags properly.
+#   Less than 1 ulp of error.  Runs 105-115 cycles for valid inputs.
+#
+#
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+# define local variable storage offsets
+.equ	p_x,0			# temporary for error checking operation
+.equ	p_idx,0x010		# index storage
+
+.equ	stack_size,0x028
+
+
+
+    .text
+    .align 16
+    .p2align 4,,15
+.globl __vrd2_log2
+    .type   __vrd2_log2,@function
+__vrd2_log2:
+	sub		$stack_size,%rsp
+
+	movdqa	%xmm0,p_x(%rsp)	# save the input values
+
+
+#      /* Store the exponent of x in xexp and put
+#         f into the range [0.5,1) */
+
+#
+# compute the index into the log tables
+#
+	pxor	%xmm1,%xmm1
+	movdqa	%xmm0,%xmm3
+	psrlq	$52,%xmm3
+	psubq	.L__mask_1023(%rip),%xmm3
+	packssdw	%xmm1,%xmm3
+	cvtdq2pd	%xmm3,%xmm6			# xexp
+	movdqa	%xmm0,%xmm2
+	xor		%rax,%rax
+	subpd	.L__real_one(%rip),%xmm2
+
+	movdqa	%xmm0,%xmm3
+	andpd	.L__real_notsign(%rip),%xmm2
+	pand	.L__real_mant(%rip),%xmm3
+	movdqa	%xmm3,%xmm4
+	movapd	.L__real_half(%rip),%xmm5							# .5
+
+	cmppd	$1,.L__real_threshold(%rip),%xmm2
+	movmskpd	%xmm2,%r10d
+	cmp		$3,%r10d
+	jz		.Lall_nearone
+
+#/* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+	psrlq	$45,%xmm3
+	movdqa	%xmm3,%xmm2
+	psrlq	$1,%xmm3
+	paddq	.L__mask_040(%rip),%xmm3
+	pand	.L__mask_001(%rip),%xmm2
+	paddq	%xmm2,%xmm3
+
+	packssdw	%xmm1,%xmm3
+	cvtdq2pd	%xmm3,%xmm1
+	xor		%rcx,%rcx
+	movq	 %xmm3,p_idx(%rsp)
+
+# reduce and get u
+	por		.L__real_half(%rip),%xmm4
+	movdqa	%xmm4,%xmm2
+
+
+	mulpd	.L__real_3f80000000000000(%rip),%xmm1		# f1 = index/128
+
+
+	lea	.L__np_ln_lead_table(%rip),%rdx
+	mov	p_idx(%rsp),%eax
+
+	subpd	%xmm1,%xmm2				# f2 = f - f1
+	mulpd	%xmm2,%xmm5
+	addpd	%xmm5,%xmm1
+
+	divpd	%xmm1,%xmm2				# u
+
+# do error checking here for scheduling.  Saves a bunch of cycles as
+# compared to doing this at the start of the routine.
+##  if NaN or inf
+	movapd	%xmm0,%xmm3
+	andpd	.L__real_inf(%rip),%xmm3
+	cmppd	$0,.L__real_inf(%rip),%xmm3
+	movmskpd	%xmm3,%r8d
+	xorpd	%xmm1,%xmm1
+
+	cmppd	$2,%xmm1,%xmm0
+	movmskpd	%xmm0,%r9d
+
+# get z
+	movlpd	 -512(%rdx,%rax,8),%xmm0		# z1
+	mov		p_idx+4(%rsp),%ecx
+	movhpd	 -512(%rdx,%rcx,8),%xmm0		# z1
+# solve for ln(1+u)
+	movapd	%xmm2,%xmm1				# u
+	mulpd	%xmm2,%xmm2				# u^2
+	movapd	%xmm2,%xmm5
+	movapd	.L__real_cb3(%rip),%xmm3
+	mulpd	%xmm2,%xmm3				#Cu2
+	mulpd	%xmm1,%xmm5				# u^3
+	addpd	.L__real_cb2(%rip),%xmm3 		#B+Cu2
+
+	mulpd	%xmm5,%xmm2				# u^5
+	movapd	.L__real_log2e_lead(%rip),%xmm4
+
+	mulpd	.L__real_cb1(%rip),%xmm5 		#Au3
+	addpd	%xmm5,%xmm1				# u+Au3
+	movapd	%xmm0,%xmm5				# z1 copy
+	mulpd	%xmm3,%xmm2				# u5(B+Cu2)
+	movapd	.L__real_log2e_tail(%rip),%xmm3
+	addpd	%xmm2,%xmm1				# poly
+# recombine
+	lea		.L__np_ln_tail_table(%rip),%rdx
+	movlpd	 -512(%rdx,%rax,8),%xmm2		#z2	+=q
+	movhpd	 -512(%rdx,%rcx,8),%xmm2		#z2	+=q
+	addpd	%xmm2,%xmm1
+	movapd	%xmm1,%xmm2	#z2 copy
+
+	mulpd	%xmm4,%xmm5	#z1*log2e_lead
+	mulpd	%xmm4,%xmm1	#z2*log2e_lead
+	mulpd	%xmm3,%xmm2	#z2*log2e_tail
+	mulpd	%xmm3,%xmm0	#z1*log2e_tail
+	addpd	%xmm6,%xmm5	#r1 = z1*log2e_lead + xexp
+	addpd	%xmm2,%xmm0	#z1*log2e_tail + z2*log2e_tail
+	addpd	%xmm1,%xmm0	#r2
+
+
+# check for nans/infs
+	test		$3,%r8d
+	addpd	%xmm5,%xmm0		#r1+r2
+	jnz		.L__log_naninf
+.L__vlog1:
+# check for negative numbers or zero
+	test		$3,%r9d
+	jnz		.L__z_or_n
+
+.L__finish:
+# see if we have a near one value
+	test		 $3,%r10d
+	jnz		.L__near_one
+.L__finishn1:
+	add		$stack_size,%rsp
+	ret
+
+	.align	16
+.Lall_nearone:
+# saves 10 cycles
+#      r = x - 1.0;
+	movapd	.L__real_two(%rip),%xmm2
+	subpd	.L__real_one(%rip),%xmm0	   # r
+#      u          = r / (2.0 + r);
+	addpd	%xmm0,%xmm2
+	movapd	%xmm0,%xmm1
+	divpd	%xmm2,%xmm1			# u
+	movapd	.L__real_ca4(%rip),%xmm4	  #D
+	movapd	.L__real_ca3(%rip),%xmm5	  #C
+#      correction = r * u;
+	movapd	%xmm0,%xmm6
+	mulpd	%xmm1,%xmm6		# correction
+#      u          = u + u;
+	addpd	%xmm1,%xmm1		#u
+	movapd	%xmm1,%xmm2
+	mulpd	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulpd	%xmm1,%xmm5		# Cu
+	movapd	%xmm1,%xmm3
+	mulpd	%xmm2,%xmm3		# u^3
+	mulpd	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulpd	%xmm3,%xmm4		#Du^3
+
+	addpd	.L__real_ca1(%rip),%xmm2	# +A
+	movapd	%xmm3,%xmm1
+	mulpd	%xmm1,%xmm1		# u^6
+	addpd	%xmm4,%xmm5		#Cu+Du3
+	movapd	.L__real_log2e_tail(%rip),%xmm4
+#	subsd	%xmm6,%xmm0		; -correction
+
+	mulpd	%xmm3,%xmm2		#u3(A+Bu2)
+	mulpd	%xmm5,%xmm1		#u6(Cu+Du3)
+	movapd	.L__real_log2e_lead(%rip),%xmm5
+	addpd	%xmm1,%xmm2
+	subpd	%xmm6,%xmm2		# -correction
+
+#	loge to log2
+	movapd  %xmm0,%xmm3		#r1 = r
+	pand	.L__mask_lower(%rip),%xmm3
+	subpd	%xmm3,%xmm0
+	addpd 	%xmm0,%xmm2		#r2 = r2 + (r - r1);
+
+	movapd 	%xmm3,%xmm0
+	movapd	%xmm2,%xmm1
+
+	mulpd 	%xmm4,%xmm2
+	mulpd 	%xmm4,%xmm0
+	mulpd 	%xmm5,%xmm1
+	mulpd 	%xmm5,%xmm3
+	addpd 	%xmm2,%xmm0
+	addpd 	%xmm1,%xmm0
+	addpd	%xmm3,%xmm0
+#      return r + r2;
+#	addpd	%xmm2,%xmm0
+	jmp		.L__finishn1
+
+	.align	16
+.L__near_one:
+	test	$1,%r10d
+	jz		.L__lnn12
+
+#	movapd	%xmm0,%xmm6		; save the inputs
+	movlpd	p_x(%rsp),%xmm0
+	call	.L__ln1
+#	shufpd	xmm0,$2,%xmm6
+
+.L__lnn12:
+	test	$2,%r10d		# second number?
+	jz		.L__lnn1e
+	movlpd	%xmm0,p_x(%rsp)
+	movlpd	p_x+8(%rsp),%xmm0
+	call	.L__ln1
+	movlpd	%xmm0,p_x+8(%rsp)
+	movapd	p_x(%rsp),%xmm0
+#	shufpd	xmm6,$0,%xmm0
+#	movapd	%xmm6,%xmm0
+
+.L__lnn1e:
+	jmp		.L__finishn1
+
+.L__ln1:
+# saves 10 cycles
+#      r = x - 1.0;
+	movlpd	.L__real_two(%rip),%xmm2
+	subsd	.L__real_one(%rip),%xmm0	# r
+#      u          = r / (2.0 + r);
+	addsd	%xmm0,%xmm2
+	movsd	%xmm0,%xmm1
+	divsd	%xmm2,%xmm1			# u
+	movlpd	.L__real_ca4(%rip),%xmm4	#D
+	movlpd	.L__real_ca3(%rip),%xmm5	#C
+#      correction = r * u;
+	movsd	%xmm0,%xmm6
+	mulsd	%xmm1,%xmm6		# correction
+#      u          = u + u;
+	addsd	%xmm1,%xmm1		#u
+	movsd	%xmm1,%xmm2
+	mulsd	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulsd	%xmm1,%xmm5		# Cu
+	movsd	%xmm1,%xmm3
+	mulsd	%xmm2,%xmm3		# u^3
+	mulsd	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulsd	%xmm3,%xmm4		#Du^3
+
+	addsd	.L__real_ca1(%rip),%xmm2	# +A
+	movsd	%xmm3,%xmm1
+	mulsd	%xmm1,%xmm1		# u^6
+	addsd	%xmm4,%xmm5		#Cu+Du3
+#	subsd	%xmm6,%xmm0		; -correction
+	movsd	.L__real_log2e_tail(%rip),%xmm4
+
+	mulsd	%xmm3,%xmm2		#u3(A+Bu2)
+	mulsd	%xmm5,%xmm1		#u6(Cu+Du3)
+	movsd	.L__real_log2e_lead(%rip),%xmm5
+	addsd	%xmm1,%xmm2
+	subsd	%xmm6,%xmm2		# -correction
+
+#	loge to log2
+	movsd 	%xmm0,%xmm3		#r1 = r
+	pand	.L__mask_lower(%rip),%xmm3
+	subsd	%xmm3,%xmm0
+	addsd 	%xmm0,%xmm2		#r2 = r2 + (r - r1);
+
+	movsd 	%xmm3,%xmm0
+	movsd	%xmm2,%xmm1
+
+	mulsd 	%xmm4,%xmm2
+	mulsd 	%xmm4,%xmm0
+	mulsd 	%xmm5,%xmm1
+	mulsd 	%xmm5,%xmm3
+	addsd 	%xmm2,%xmm0
+	addsd 	%xmm1,%xmm0
+	addsd	%xmm3,%xmm0
+
+#      return r + r2;
+#	addsd	%xmm2,%xmm0
+	ret
+
+	.align	16
+
+# at least one of the numbers was a nan or infinity
+.L__log_naninf:
+	test		$1,%r8d		# first number?
+	jz		.L__lninf2
+
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x(%rsp),%rdx
+	movlpd	p_x(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$2,%xmm1,%xmm0
+
+.L__lninf2:
+	test		$2,%r8d		# second number?
+	jz		.L__lninfe
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov	p_x+8(%rsp),%rdx
+	movlpd	p_x+8(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$0,%xmm0,%xmm1
+	movapd	%xmm1,%xmm0
+
+.L__lninfe:
+
+	cmp		$3,%r8d		# both numbers?
+	jz		.L__finish	# return early if so
+	jmp		.L__vlog1	# continue processing if not
+
+# a subroutine to treat one number for nan/infinity
+# the number is expected in rdx and returned in the low
+# half of xmm0
+.L__lni:
+	mov		$0x0000FFFFFFFFFFFFF,%rax
+	test	%rax,%rdx
+	jnz		.L__lnan	# jump if mantissa not zero, so it's a NaN
+# inf
+	rcl		$1,%rdx
+	jnc		.L__lne2	# log(+inf) = inf
+# negative x
+	movlpd	.L__real_nan(%rip),%xmm0
+	ret
+
+#NaN
+.L__lnan:
+	mov		$0x00008000000000000,%rax	# convert to quiet
+	or		%rax,%rdx
+.L__lne:
+	movd	%rdx,%xmm0
+.L__lne2:
+	ret
+
+	.align	16
+
+# at least one of the numbers was a zero, a negative number, or both.
+.L__z_or_n:
+	test		$1,%r9d		# first number?
+	jz		.L__zn2
+
+#	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x(%rsp),%rax
+	call	.L__zni
+#	shufpd	$2,%xmm1,%xmm0
+
+.L__zn2:
+	test		$2,%r9d		# second number?
+	jz		.L__zne
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x+8(%rsp),%rax
+	call	.L__zni
+	shufpd	$0,%xmm0,%xmm1
+	movapd	%xmm1,%xmm0
+
+.L__zne:
+	jmp		.L__finish
+
+# a subroutine to treat one number for zero or negative values
+# the number is expected in rax and returned in the low
+# half of xmm0
+.L__zni:
+	shl		$1,%rax
+	jnz		.L__zn_x		 ## if just a carry, then must be negative
+	movlpd	.L__real_ninf(%rip),%xmm0  # C99 specs -inf for +-0
+	ret
+.L__zn_x:
+	movlpd	.L__real_nan(%rip),%xmm0
+	ret
+
+
+
+
+	.data
+	.align	16
+
+.L__real_one:			.quad 0x03ff0000000000000	# 1.0
+				.quad 0x03ff0000000000000
+.L__real_two:			.quad 0x04000000000000000	# 2.0
+				.quad 0x04000000000000000
+.L__real_ninf:			.quad 0x0fff0000000000000	# -inf
+				.quad 0x0fff0000000000000
+.L__real_inf:			.quad 0x07ff0000000000000	# +inf
+				.quad 0x07ff0000000000000
+.L__real_nan:			.quad 0x07ff8000000000000	# NaN
+				.quad 0x07ff8000000000000
+
+.L__real_sign:			.quad 0x08000000000000000	# sign bit
+				.quad 0x08000000000000000
+.L__real_notsign:		.quad 0x07ffFFFFFFFFFFFFF	# ^sign bit
+				.quad 0x07ffFFFFFFFFFFFFF
+.L__real_threshold:		.quad 0x03F9EB85000000000	# .03
+				.quad 0x03F9EB85000000000
+.L__real_qnanbit:		.quad 0x00008000000000000	# quiet nan bit
+				.quad 0x00008000000000000
+.L__real_mant:			.quad 0x0000FFFFFFFFFFFFF	# mantissa bits
+				.quad 0x0000FFFFFFFFFFFFF
+.L__real_3f80000000000000:	.quad 0x03f80000000000000	# /* 0.0078125 = 1/128 */
+				.quad 0x03f80000000000000
+.L__mask_1023:			.quad 0x000000000000003ff	#
+				.quad 0x000000000000003ff
+.L__mask_040:			.quad 0x00000000000000040	#
+				.quad 0x00000000000000040
+.L__mask_001:			.quad 0x00000000000000001	#
+				.quad 0x00000000000000001
+
+.L__real_ca1:			.quad 0x03fb55555555554e6	# 8.33333333333317923934e-02
+				.quad 0x03fb55555555554e6
+.L__real_ca2:			.quad 0x03f89999999bac6d4	# 1.25000000037717509602e-02
+				.quad 0x03f89999999bac6d4
+.L__real_ca3:			.quad 0x03f62492307f1519f	# 2.23213998791944806202e-03
+				.quad 0x03f62492307f1519f
+.L__real_ca4:			.quad 0x03f3c8034c85dfff0	# 4.34887777707614552256e-04
+				.quad 0x03f3c8034c85dfff0
+
+.L__real_cb1:			.quad 0x03fb5555555555557	# 8.33333333333333593622e-02
+				.quad 0x03fb5555555555557
+.L__real_cb2:			.quad 0x03f89999999865ede	# 1.24999999978138668903e-02
+				.quad 0x03f89999999865ede
+.L__real_cb3:			.quad 0x03f6249423bd94741	# 2.23219810758559851206e-03
+				.quad 0x03f6249423bd94741
+.L__real_log2_lead:  		.quad 0x03fe62e42e0000000	# log2_lead	  6.93147122859954833984e-01
+				.quad 0x03fe62e42e0000000
+.L__real_log2_tail: 		.quad 0x03e6efa39ef35793c	# log2_tail	  5.76999904754328540596e-08
+				.quad 0x03e6efa39ef35793c
+
+.L__real_half:			.quad 0x03fe0000000000000	# 1/2
+				.quad 0x03fe0000000000000
+.L__real_log2e_lead:		.quad 0x03FF7154400000000	# log2e_lead	  1.44269180297851562500E+00
+						.quad 0x03FF7154400000000
+.L__real_log2e_tail :		.quad 0x03ECB295C17F0BBBE	# log2e_tail	  3.23791044778235969970E-06
+						.quad 0x03ECB295C17F0BBBE
+.L__mask_lower:			.quad 0x0ffffffff00000000
+						.quad 0x0ffffffff00000000
+	.align	16
+
+.L__np_ln_lead_table:
+	.quad	0x0000000000000000 		# 0.00000000000000000000e+00
+	.quad	0x3f8fc0a800000000		# 1.55041813850402832031e-02
+	.quad	0x3f9f829800000000		# 3.07716131210327148438e-02
+	.quad	0x3fa7745800000000		# 4.58095073699951171875e-02
+	.quad	0x3faf0a3000000000		# 6.06245994567871093750e-02
+	.quad	0x3fb341d700000000		# 7.52233862876892089844e-02
+	.quad	0x3fb6f0d200000000		# 8.96121263504028320312e-02
+	.quad	0x3fba926d00000000		# 1.03796780109405517578e-01
+	.quad	0x3fbe270700000000		# 1.17783010005950927734e-01
+	.quad	0x3fc0d77e00000000		# 1.31576299667358398438e-01
+	.quad	0x3fc2955280000000		# 1.45181953907012939453e-01
+	.quad	0x3fc44d2b00000000		# 1.58604979515075683594e-01
+	.quad	0x3fc5ff3000000000		# 1.71850204467773437500e-01
+	.quad	0x3fc7ab8900000000		# 1.84922337532043457031e-01
+	.quad	0x3fc9525a80000000		# 1.97825729846954345703e-01
+	.quad	0x3fcaf3c900000000		# 2.10564732551574707031e-01
+	.quad	0x3fcc8ff780000000		# 2.23143517971038818359e-01
+	.quad	0x3fce270700000000		# 2.35566020011901855469e-01
+	.quad	0x3fcfb91800000000		# 2.47836112976074218750e-01
+	.quad	0x3fd0a324c0000000		# 2.59957492351531982422e-01
+	.quad	0x3fd1675c80000000		# 2.71933674812316894531e-01
+	.quad	0x3fd22941c0000000		# 2.83768117427825927734e-01
+	.quad	0x3fd2e8e280000000		# 2.95464158058166503906e-01
+	.quad	0x3fd3a64c40000000		# 3.07025015354156494141e-01
+	.quad	0x3fd4618bc0000000		# 3.18453729152679443359e-01
+	.quad	0x3fd51aad80000000		# 3.29753279685974121094e-01
+	.quad	0x3fd5d1bd80000000		# 3.40926527976989746094e-01
+	.quad	0x3fd686c800000000		# 3.51976394653320312500e-01
+	.quad	0x3fd739d7c0000000		# 3.62905442714691162109e-01
+	.quad	0x3fd7eaf800000000		# 3.73716354370117187500e-01
+	.quad	0x3fd89a3380000000		# 3.84411692619323730469e-01
+	.quad	0x3fd9479400000000		# 3.94993782043457031250e-01
+	.quad	0x3fd9f323c0000000		# 4.05465066432952880859e-01
+	.quad	0x3fda9cec80000000		# 4.15827870368957519531e-01
+	.quad	0x3fdb44f740000000		# 4.26084339618682861328e-01
+	.quad	0x3fdbeb4d80000000		# 4.36236739158630371094e-01
+	.quad	0x3fdc8ff7c0000000		# 4.46287095546722412109e-01
+	.quad	0x3fdd32fe40000000		# 4.56237375736236572266e-01
+	.quad	0x3fddd46a00000000		# 4.66089725494384765625e-01
+	.quad	0x3fde744240000000		# 4.75845873355865478516e-01
+	.quad	0x3fdf128f40000000		# 4.85507786273956298828e-01
+	.quad	0x3fdfaf5880000000		# 4.95077252388000488281e-01
+	.quad	0x3fe02552a0000000		# 5.04556000232696533203e-01
+	.quad	0x3fe0723e40000000		# 5.13945698738098144531e-01
+	.quad	0x3fe0be72e0000000		# 5.23248136043548583984e-01
+	.quad	0x3fe109f380000000		# 5.32464742660522460938e-01
+	.quad	0x3fe154c3c0000000		# 5.41597247123718261719e-01
+	.quad	0x3fe19ee6a0000000		# 5.50647079944610595703e-01
+	.quad	0x3fe1e85f40000000		# 5.59615731239318847656e-01
+	.quad	0x3fe23130c0000000		# 5.68504691123962402344e-01
+	.quad	0x3fe2795e00000000		# 5.77315330505371093750e-01
+	.quad	0x3fe2c0e9e0000000		# 5.86049020290374755859e-01
+	.quad	0x3fe307d720000000		# 5.94707071781158447266e-01
+	.quad	0x3fe34e2880000000		# 6.03290796279907226562e-01
+	.quad	0x3fe393e0c0000000		# 6.11801505088806152344e-01
+	.quad	0x3fe3d90260000000		# 6.20240390300750732422e-01
+	.quad	0x3fe41d8fe0000000		# 6.28608644008636474609e-01
+	.quad	0x3fe4618bc0000000		# 6.36907458305358886719e-01
+	.quad	0x3fe4a4f840000000		# 6.45137906074523925781e-01
+	.quad	0x3fe4e7d800000000		# 6.53301239013671875000e-01
+	.quad	0x3fe52a2d20000000		# 6.61398470401763916016e-01
+	.quad	0x3fe56bf9c0000000		# 6.69430613517761230469e-01
+	.quad	0x3fe5ad4040000000		# 6.77398800849914550781e-01
+	.quad	0x3fe5ee02a0000000		# 6.85303986072540283203e-01
+	.quad	0x3fe62e42e0000000		# 6.93147122859954833984e-01
+	.quad 0					# for alignment
+
+.L__np_ln_tail_table:
+	.quad	0x00000000000000000 # 0	; 0.00000000000000000000e+00
+	.quad	0x03e361f807c79f3db		# 5.15092497094772879206e-09
+	.quad	0x03e6873c1980267c8		# 4.55457209735272790188e-08
+	.quad	0x03e5ec65b9f88c69e		# 2.86612990859791781788e-08
+	.quad	0x03e58022c54cc2f99		# 2.23596477332056055352e-08
+	.quad	0x03e62c37a3a125330		# 3.49498983167142274770e-08
+	.quad	0x03e615cad69737c93		# 3.23392843005887000414e-08
+	.quad	0x03e4d256ab1b285e9		# 1.35722380472479366661e-08
+	.quad	0x03e5b8abcb97a7aa2		# 2.56504325268044191098e-08
+	.quad	0x03e6f34239659a5dc		# 5.81213608741512136843e-08
+	.quad	0x03e6e07fd48d30177		# 5.59374849578288093334e-08
+	.quad	0x03e6b32df4799f4f6		# 5.06615629004996189970e-08
+	.quad	0x03e6c29e4f4f21cf8		# 5.24588857848400955725e-08
+	.quad	0x03e1086c848df1b59		# 9.61968535632653505972e-10
+	.quad	0x03e4cf456b4764130		# 1.34829655346594463137e-08
+	.quad	0x03e63a02ffcb63398		# 3.65557749306383026498e-08
+	.quad	0x03e61e6a6886b0976		# 3.33431709374069198903e-08
+	.quad	0x03e6b8abcb97a7aa2		# 5.13008650536088382197e-08
+	.quad	0x03e6b578f8aa35552		# 5.09285070380306053751e-08
+	.quad	0x03e6139c871afb9fc		# 3.20853940845502057341e-08
+	.quad	0x03e65d5d30701ce64		# 4.06713248643004200446e-08
+	.quad	0x03e6de7bcb2d12142		# 5.57028186706125221168e-08
+	.quad	0x03e6d708e984e1664		# 5.48356693724804282546e-08
+	.quad	0x03e556945e9c72f36		# 1.99407553679345001938e-08
+	.quad	0x03e20e2f613e85bda		# 1.96585517245087232086e-09
+	.quad	0x03e3cb7e0b42724f6		# 6.68649386072067321503e-09
+	.quad	0x03e6fac04e52846c7		# 5.89936034642113390002e-08
+	.quad	0x03e5e9b14aec442be		# 2.85038578721554472484e-08
+	.quad	0x03e6b5de8034e7126		# 5.09746772910284482606e-08
+	.quad	0x03e6dc157e1b259d3		# 5.54234668933210171467e-08
+	.quad	0x03e3b05096ad69c62		# 6.29100830926604004874e-09
+	.quad	0x03e5c2116faba4cdd		# 2.61974119468563937716e-08
+	.quad	0x03e665fcc25f95b47		# 4.16752115011186398935e-08
+	.quad	0x03e5a9a08498d4850		# 2.47747534460820790327e-08
+	.quad	0x03e6de647b1465f77		# 5.56922172017964209793e-08
+	.quad	0x03e5da71b7bf7861d		# 2.76162876992552906035e-08
+	.quad	0x03e3e6a6886b09760		# 7.08169709942321478061e-09
+	.quad	0x03e6f0075eab0ef64		# 5.77453510221151779025e-08
+	.quad	0x03e33071282fb989b		# 4.43021445893361960146e-09
+	.quad	0x03e60eb43c3f1bed2		# 3.15140984357495864573e-08
+	.quad	0x03e5faf06ecb35c84		# 2.95077445089736670973e-08
+	.quad	0x03e4ef1e63db35f68		# 1.44098510263167149349e-08
+	.quad	0x03e469743fb1a71a5		# 1.05196987538551827693e-08
+	.quad	0x03e6c1cdf404e5796		# 5.23641361722697546261e-08
+	.quad	0x03e4094aa0ada625e		# 7.72099925253243069458e-09
+	.quad	0x03e6e2d4c96fde3ec		# 5.62089493829364197156e-08
+	.quad	0x03e62f4d5e9a98f34		# 3.53090261098577946927e-08
+	.quad	0x03e6467c96ecc5cbe		# 3.80080516835568242269e-08
+	.quad	0x03e6e7040d03dec5a		# 5.66961038386146408282e-08
+	.quad	0x03e67bebf4282de36		# 4.42287063097349852717e-08
+	.quad	0x03e6289b11aeb783f		# 3.45294525105681104660e-08
+	.quad	0x03e5a891d1772f538		# 2.47132034530447431509e-08
+	.quad	0x03e634f10be1fb591		# 3.59655343422487209774e-08
+	.quad	0x03e6d9ce1d316eb93		# 5.51581770357780862071e-08
+	.quad	0x03e63562a19a9c442		# 3.60171867511861372793e-08
+	.quad	0x03e54e2adf548084c		# 1.94511067964296180547e-08
+	.quad	0x03e508ce55cc8c97a		# 1.54137376631349347838e-08
+	.quad	0x03e30e2f613e85bda		# 3.93171034490174464173e-09
+	.quad	0x03e6db03ebb0227bf		# 5.52990607758839766440e-08
+	.quad	0x03e61b75bb09cb098		# 3.29990737637586136511e-08
+	.quad	0x03e496f16abb9df22		# 1.18436010922446096216e-08
+	.quad	0x03e65b3f399411c62		# 4.04248680368301346709e-08
+	.quad	0x03e586b3e59f65355		# 2.27418915900284316293e-08
+	.quad	0x03e52482ceae1ac12		# 1.70263791333409206020e-08
+	.quad	0x03e6efa39ef35793c		# 5.76999904754328540596e-08
+	.quad 0					# for alignment
+
+
diff --git a/src/gas/vrd2sin.S b/src/gas/vrd2sin.S
new file mode 100644
index 0000000..50c0deb
--- /dev/null
+++ b/src/gas/vrd2sin.S
@@ -0,0 +1,805 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# A vector implementation of the libm sin function.
+#
+# Prototype:
+#
+#     __m128d __vrd2_sin(__m128d x);
+#
+#   Computes Sine of x
+#   It will provide proper C99 return values,
+#   but may not raise floating point status bits properly.
+#   Based on the NAG C implementation.
+#   Author: Harsha Jagasia
+#   Email:  harsha.jagasia@amd.com
+
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+
+.data
+.align 16
+.L__real_7fffffffffffffff: 	.quad 0x07fffffffffffffff	#Sign bit zero
+				.quad 0x07fffffffffffffff
+.L__real_3ff0000000000000: 	.quad 0x03ff0000000000000	# 1.0
+				.quad 0x03ff0000000000000
+.L__real_v2p__27:		.quad 0x03e40000000000000	# 2p-27
+				.quad 0x03e40000000000000
+.L__real_3fe0000000000000: 	.quad 0x03fe0000000000000	# 0.5
+				.quad 0x03fe0000000000000
+.L__real_3fc5555555555555: 	.quad 0x03fc5555555555555	# 0.166666666666
+				.quad 0x03fc5555555555555
+.L__real_3fe45f306dc9c883: 	.quad 0x03fe45f306dc9c883	# twobypi
+				.quad 0x03fe45f306dc9c883
+.L__real_3ff921fb54400000: 	.quad 0x03ff921fb54400000	# piby2_1
+				.quad 0x03ff921fb54400000
+.L__real_3dd0b4611a626331: 	.quad 0x03dd0b4611a626331	# piby2_1tail
+				.quad 0x03dd0b4611a626331
+.L__real_3dd0b4611a600000: 	.quad 0x03dd0b4611a600000	# piby2_2
+				.quad 0x03dd0b4611a600000
+.L__real_3ba3198a2e037073: 	.quad 0x03ba3198a2e037073	# piby2_2tail
+				.quad 0x03ba3198a2e037073
+.L__real_fffffffff8000000: 	.quad 0x0fffffffff8000000	# mask for stripping head and tail
+				.quad 0x0fffffffff8000000
+.L__real_8000000000000000:	.quad 0x08000000000000000	# -0  or signbit
+				.quad 0x08000000000000000
+.L__reald_one_one:		.quad 0x00000000100000001	#
+				.quad 0
+.L__reald_two_two:		.quad 0x00000000200000002	#
+				.quad 0
+.L__reald_one_zero:		.quad 0x00000000100000000	# sin_cos_filter
+				.quad 0
+.L__reald_zero_one:		.quad 0x00000000000000001	#
+				.quad 0
+.L__reald_two_zero:		.quad 0x00000000200000000	#
+				.quad 0
+.L__realq_one_one:		.quad 0x00000000000000001	#
+				.quad 0x00000000000000001	#
+.L__realq_two_two:		.quad 0x00000000000000002	#
+				.quad 0x00000000000000002	#
+.L__real_1_x_mask:		.quad 0x0ffffffffffffffff	#
+				.quad 0x03ff0000000000000	#
+.L__real_zero:			.quad 0x00000000000000000	#
+				.quad 0x00000000000000000	#
+.L__real_one:			.quad 0x00000000000000001	#
+				.quad 0x00000000000000001	#
+.L__real_ffffffffffffffff: 	.quad 0x0ffffffffffffffff	#Sign bit one
+				.quad 0x0ffffffffffffffff
+
+.Lcosarray:
+	.quad	0x03fa5555555555555		#  0.0416667		   	c1
+	.quad	0x03fa5555555555555
+	.quad	0x0bf56c16c16c16967		# -0.00138889	   		c2
+	.quad	0x0bf56c16c16c16967
+	.quad	0x03efa01a019f4ec90		#  2.48016e-005			c3
+	.quad	0x03efa01a019f4ec90
+	.quad	0x0be927e4fa17f65f6		# -2.75573e-007			c4
+	.quad	0x0be927e4fa17f65f6
+	.quad	0x03e21eeb69037ab78		#  2.08761e-009			c5
+	.quad	0x03e21eeb69037ab78
+	.quad	0x0bda907db46cc5e42		# -1.13826e-011	   		c6
+	.quad	0x0bda907db46cc5e42
+.Lsinarray:
+	.quad	0x0bfc5555555555555		# -0.166667	   		s1
+	.quad	0x0bfc5555555555555
+	.quad	0x03f81111111110bb3		#  0.00833333	   		s2
+	.quad	0x03f81111111110bb3
+	.quad	0x0bf2a01a019e83e5c		# -0.000198413			s3
+	.quad	0x0bf2a01a019e83e5c
+	.quad	0x03ec71de3796cde01		#  2.75573e-006			s4
+	.quad	0x03ec71de3796cde01
+	.quad	0x0be5ae600b42fdfa7		# -2.50511e-008			s5
+	.quad	0x0be5ae600b42fdfa7
+	.quad	0x03de5e0b2f9a43bb8		#  1.59181e-010	   		s6
+	.quad	0x03de5e0b2f9a43bb8
+.Lsincosarray:
+	.quad	0x0bfc5555555555555		# -0.166667	   		s1
+	.quad	0x03fa5555555555555		#  0.0416667		   	c1
+	.quad	0x03f81111111110bb3		#  0.00833333	   		s2
+	.quad	0x0bf56c16c16c16967		#				c2
+	.quad	0x0bf2a01a019e83e5c		# -0.000198413			s3
+	.quad	0x03efa01a019f4ec90
+	.quad	0x03ec71de3796cde01		#  2.75573e-006			s4
+	.quad	0x0be927e4fa17f65f6
+	.quad	0x0be5ae600b42fdfa7		# -2.50511e-008			s5
+	.quad	0x03e21eeb69037ab78
+	.quad	0x03de5e0b2f9a43bb8		#  1.59181e-010	   		s6
+	.quad	0x0bda907db46cc5e42
+.Lcossinarray:
+	.quad	0x03fa5555555555555		#  0.0416667		   	c1
+	.quad	0x0bfc5555555555555		# -0.166667	   		s1
+	.quad	0x0bf56c16c16c16967		#				c2
+	.quad	0x03f81111111110bb3		#  0.00833333	   		s2
+	.quad	0x03efa01a019f4ec90
+	.quad	0x0bf2a01a019e83e5c		# -0.000198413			s3
+	.quad	0x0be927e4fa17f65f6
+	.quad	0x03ec71de3796cde01		#  2.75573e-006			s4
+	.quad	0x03e21eeb69037ab78
+	.quad	0x0be5ae600b42fdfa7		# -2.50511e-008			s5
+	.quad	0x0bda907db46cc5e42
+	.quad	0x03de5e0b2f9a43bb8		#  1.59181e-010	   		s6
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    .text
+    .align 16
+    .p2align 4,,15
+
+.equ	p_temp,	0x00		# temporary for get/put bits operation
+.equ	p_temp1,0x10		# temporary for get/put bits operation
+.equ	p_temp2,0x20		# temporary for get/put bits operation
+.equ	p_xmm6,	0x30		# temporary for get/put bits operation
+.equ	p_xmm7,	0x40		# temporary for get/put bits operation
+.equ	p_xmm8,	0x50		# temporary for get/put bits operation
+.equ	p_xmm9,	0x60		# temporary for get/put bits operation
+.equ	p_xmm10,0x70		# temporary for get/put bits operation
+.equ	p_xmm11,0x80		# temporary for get/put bits operation
+.equ	p_xmm12,0x90		# temporary for get/put bits operation
+.equ	p_xmm13,0x0A0		# temporary for get/put bits operation
+.equ	p_xmm14,0x0B0		# temporary for get/put bits operation
+.equ	p_xmm15,0x0C0		# temporary for get/put bits operation
+.equ	r,	0x0D0		# pointer to r for remainder_piby2
+.equ	rr,	0x0E0		# pointer to r for remainder_piby2
+.equ	region,	0x0F0		# pointer to r for remainder_piby2
+.equ	p_original,0x100	# original x
+.equ	p_mask,	0x110		# original x
+.equ	p_sign,	0x120		# original x
+
+.globl __vrd2_sin
+    .type   __vrd2_sin,@function
+__vrd2_sin:
+
+	sub		$0x138,%rsp
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#STARTMAIN
+movdqa 	%xmm0,%xmm6					#move to mem to get into integer regs **
+andpd 	.L__real_7fffffffffffffff(%rip), %xmm0		#Unsign			-
+
+movd	%xmm0,%rax					#rax is lower arg	+
+movhpd	%xmm0, p_temp+8(%rsp)				#			+
+mov    	p_temp+8(%rsp),%rcx				#rcx = upper arg	+
+movdqa	%xmm0,%xmm1
+
+							#This will mask all nan/infs also
+pcmpgtd		%xmm6,%xmm1
+movdqa		%xmm1,%xmm6
+psrldq		$4, %xmm1
+psrldq		$8, %xmm6
+
+mov 	$0x3FE921FB54442D18,%rdx			#piby4	+
+mov	$0x411E848000000000,%r10			#5e5	+
+
+movapd	.L__real_3fe0000000000000(%rip), %xmm5		#0.5 for later use	+
+
+por	%xmm1,%xmm6
+movd	%xmm6,%r11					#Move Sign to gpr **
+
+movapd	%xmm0,%xmm2					#x	+
+movapd	%xmm0,%xmm4					#x	+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Leither_or_both_arg_gt_than_piby4:
+
+	cmp	%r10,%rax				#is lower arg >= 5e5
+	jae	.Llower_or_both_arg_gt_5e5
+	cmp	%r10,%rcx				#is upper arg >= 5e5
+	jae	.Lupper_arg_gt_5e5
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lboth_arg_lt_than_5e5:
+# %xmm2,,%xmm0 xmm4 = x, xmm5 = 0.5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm2	# x*twobypi
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm3	# xmm3=piby2_1
+	addpd	%xmm5,%xmm2				# xmm2 = npi2 = x*twobypi+0.5
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm1	# xmm1=piby2_2
+	movapd	.L__real_3ba3198a2e037073(%rip),%xmm6	# xmm6=piby2_2tail
+	cvttpd2dq	%xmm2,%xmm0			# xmm0=convert npi2 to ints
+	cvtdq2pd	%xmm0,%xmm2			# xmm2=and back to double.
+
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulpd	%xmm2,%xmm3				# npi2 * piby2_1
+	subpd	%xmm3,%xmm4				# xmm4 = rhead=x-npi2*piby2_1
+
+#t  = rhead;
+       movapd	%xmm4,%xmm5				# xmm5=t=rhead
+
+#rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm1				# xmm1= npi2*piby2_2
+
+#rhead  = t - rtail;
+       subpd	%xmm1,%xmm4				# xmm4= rhead = t-rtail
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	%xmm2,%xmm6     				# npi2 * piby2_2tail
+       subpd	%xmm4,%xmm5				# t-rhead
+       subpd	%xmm5,%xmm1				# rtail-(t - rhead)
+       addpd	%xmm6,%xmm1				# rtail=npi2*piby2_2+(rtail-(t-rhead))
+
+#r = rhead - rtail
+#rr=(rhead-r) -rtail
+#Sign
+#Region
+	movdqa		%xmm0,%xmm5			# Region			+
+	movd		%xmm0,%r10			# Sign
+	movdqa		%xmm4,%xmm0			# rhead (handle xmm0 retype)	+
+
+	subpd	%xmm1,%xmm0				# rhead - rtail			+
+	pand 	.L__reald_one_one(%rip),%xmm5		# Odd/Even region for Cos/Sin	+
+	mov 	.L__reald_one_zero(%rip),%r9		# Compare value for cossin	+
+	subpd	%xmm0,%xmm4				# rr=rhead-r			+
+	movd 	%xmm5,%r8				# Region			+
+	movapd	%xmm0,%xmm2				# Move for x2			+
+	mulpd	%xmm0,%xmm2				# x2				+
+	subpd	%xmm1,%xmm4				# rr=(rhead-r) -rtail		+
+
+	shr	$1,%r10					#~AB+A~B, A is sign and B is upper bit of region
+	mov	%r10,%rcx
+	not 	%r11					#ADDED TO CHANGE THE LOGIC
+	and	%r11,%r10
+	not	%rcx
+	not	%r11
+	and	%r11,%rcx
+	or	%rcx,%r10
+	and	.L__reald_one_one(%rip),%r10			#(~AB+A~B)&1
+
+	mov	%r10,%r11
+	and	%r9,%r11				#mask out the lower sign bit leaving the upper sign bit
+	shl	$63,%r10				#shift lower sign bit left by 63 bits
+	shl	$31,%r11				#shift upper sign bit left by 31 bits
+	mov 	 %r10,p_sign(%rsp)			#write out lower sign bit
+	mov 	 %r11,p_sign+8(%rsp)			#write out upper sign bit
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#xmm0= x, xmm2 = x2, xmm4 = xx, r8 = region, r9 = compare value for sincos path, xmm6 = Sign
+
+.align 16
+.L__vrd2_sin_approximate:
+	cmp 	$0,%r8
+	jnz	.Lvrd2_not_sin_piby4
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lvrd2_sin_piby4:
+	movapd	.Lsinarray+0x50(%rip),%xmm3	# s6
+	movapd	.Lsinarray+0x20(%rip),%xmm5	# s3
+	movapd	%xmm2,%xmm1			# move for x4
+
+	mulpd	%xmm2,%xmm3			# x2s6
+	mulpd	%xmm2,%xmm5			# x2s3
+	mulpd	%xmm2,%xmm1			# x4
+
+	addpd	.Lsinarray+0x40(%rip),%xmm3	# s5+x2s6
+	movapd	%xmm2,%xmm6			# move for x3
+	addpd	.Lsinarray+0x10(%rip),%xmm5	# s2+x2s3
+
+	mulpd	%xmm2,%xmm3			# x2(s5+x2s6)
+	mulpd	%xmm2,%xmm5			# x2(s2+x2s3)
+	mulpd	%xmm2,%xmm1			# x6
+
+	addpd	.Lsinarray+0x30(%rip),%xmm3	# s4 + x2(s5+x2s6)
+	addpd	.Lsinarray(%rip),%xmm5		# s1+x2(s2+x2s3)
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm2 # 0.5 *x2
+
+	mulpd	%xmm1,%xmm3			# x6(s4 + x2(s5+x2s6))
+	mulpd	%xmm0,%xmm6			# x3
+	addpd	%xmm5,%xmm3			# zs
+	mulpd	%xmm4,%xmm2			# 0.5 * x2 *xx
+
+	mulpd	%xmm3,%xmm6			# x3*zs
+	subpd	%xmm2,%xmm6			# x3*zs - 0.5 * x2 *xx
+	addpd	%xmm4,%xmm6			# +xx
+	addpd	%xmm6,%xmm0			# +x
+	xorpd	p_sign(%rsp),%xmm0	# xor sign
+	jmp .L__vrd2_sin_cleanup
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#xmm0= x, xmm2 = x2, xmm4 = xx, r8 = region, r9 = compare value for sincos path, xmm6 = Sign
+.align 16
+.Lvrd2_not_sin_piby4:
+	cmp 	$1,%r8
+	jnz	.Lvrd2_not_sin_cos_piby4
+
+.Lvrd2_sin_cos_piby4:
+
+	movapd	 %xmm4,p_temp(%rsp)		# rr move to to memory
+	movapd	 %xmm0,p_temp1(%rsp)		# r move to to memory
+
+	movapd	.Lcossinarray+0x50(%rip),%xmm3		# s6
+	mulpd	%xmm2,%xmm3				# x2s6
+	movdqa	.Lcossinarray+0x20(%rip),%xmm5		# s3
+	movapd	%xmm2,%xmm1				# move x2 for x4
+	mulpd	%xmm2,%xmm1				# x4
+	mulpd	%xmm2,%xmm5				# x2s3
+
+	addpd	.Lcossinarray+0x40(%rip),%xmm3		# s5+x2s6
+	movapd	%xmm2,%xmm4				# move for x6
+	mulpd	%xmm2,%xmm3				# x2(s5+x2s6)
+	mulpd	%xmm1,%xmm4				# x6
+	addpd	.Lcossinarray+0x10(%rip),%xmm5		# s2+x2s3
+	mulpd	%xmm2,%xmm5				# x2(s2+x2s3)
+	addpd	.Lcossinarray+0x30(%rip),%xmm3		# s4 + x2(s5+x2s6)
+
+	movhlps	%xmm0,%xmm0				# high of x for x3
+	mulpd	%xmm4,%xmm3				# x6(s4 + x2(s5+x2s6))
+	addpd	.Lcossinarray(%rip),%xmm5		# s1+x2(s2+x2s3)
+
+	movhlps	%xmm2,%xmm4				# high of x2 for x3
+	addpd	%xmm5,%xmm3				# z
+
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2
+	mulsd	%xmm0,%xmm4				# x3 #
+	movhlps	%xmm3,%xmm5				# xmm5 = sin
+							# xmm3 = cos
+
+	mulsd	%xmm4,%xmm5				# sin*x3 #
+	movsd	.L__real_3ff0000000000000(%rip),%xmm4	# 1.0 #
+	mulsd	%xmm1,%xmm3				# cos*x4 #
+
+	subsd	%xmm2,%xmm4 				# t=1.0-r #
+
+	movhlps	%xmm2,%xmm6				# move 0.5 * x2 for 0.5 * x2 * xx #
+	mulsd	p_temp+8(%rsp),%xmm6			# 0.5 * x2 * xx #
+	subsd	%xmm6,%xmm5				# sin - 0.5 * x2 *xx #
+	addsd	p_temp+8(%rsp),%xmm5			# sin+xx #
+
+	movlpd	p_temp1(%rsp),%xmm6			# x
+	mulsd	p_temp(%rsp),%xmm6			# x *xx #
+
+	movsd	.L__real_3ff0000000000000(%rip),%xmm1	# 1 #
+	subsd	%xmm4,%xmm1				# 1 -t #
+	addsd	%xmm5,%xmm0				# sin+x #
+	subsd	%xmm2,%xmm1				# (1-t) - r #
+	subsd	%xmm6,%xmm1				# ((1 + (-t)) - r) - x*xx #
+	addsd   %xmm1,%xmm3				# cos+((1 + (-t)) - r) - x*xx #
+	addsd   %xmm4,%xmm3				# cos+t #
+
+	movapd	p_sign(%rsp),%xmm2			# load sign
+	movlhps %xmm0,%xmm3
+	movapd	%xmm3,%xmm0
+	xorpd	%xmm2,%xmm0
+	jmp .L__vrd2_sin_cleanup
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#xmm0= x, xmm2 = x2, xmm4 = xx, r8 = region, r9 = compare value for sincos path, xmm6 = Sign
+.align 16
+.Lvrd2_not_sin_cos_piby4:
+	cmp 	%r9,%r8
+	jnz	.Lvrd2_cos_piby4
+
+.Lvrd2_cos_sin_piby4:
+
+	movapd	 %xmm4,p_temp(%rsp)		# Store rr
+	movapd	.Lsincosarray+0x50(%rip),%xmm3		# s6
+	mulpd	%xmm2,%xmm3				# x2s6
+	movdqa	.Lsincosarray+0x20(%rip),%xmm5		# s3 (handle xmm5 retype)
+	movapd	%xmm2,%xmm1				# move x2 for x4
+	mulpd	%xmm2,%xmm1				# x4
+	mulpd	%xmm2,%xmm5				# x2s3
+	addpd	.Lsincosarray+0x40(%rip),%xmm3		# s5+x2s6
+	movapd	%xmm2,%xmm4				# move x2 for x6
+	mulpd	%xmm2,%xmm3				# x2(s5+x2s6)
+	mulpd	%xmm1,%xmm4				# x6
+	addpd	.Lsincosarray+0x10(%rip),%xmm5		# s2+x2s3
+	mulpd	%xmm2,%xmm5				# x2(s2+x2s3)
+	addpd	.Lsincosarray+0x30(%rip),%xmm3		# s4+x2(s5+x2s6)
+
+	movhlps	%xmm1,%xmm1				# move high x4 for cos
+	mulpd	%xmm4,%xmm3				# x6(s4+x2(s5+x2s6))
+	addpd	.Lsincosarray(%rip),%xmm5		# s1+x2(s2+x2s3)
+	movapd	%xmm2,%xmm4				# move low x2 for x3
+	mulsd	%xmm0,%xmm4				# get low x3 for sin term
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2
+
+	addpd	%xmm3,%xmm5				# z
+	movhlps	%xmm2,%xmm6				# move high r for cos
+	movhlps	%xmm5,%xmm3				# xmm5 = sin
+							# xmm3 = cos
+	mulsd	p_temp(%rsp),%xmm2		# 0.5 * x2 * xx
+
+	mulsd	%xmm4,%xmm5				# sin *x3
+	movsd	.L__real_3ff0000000000000(%rip),%xmm4	# 1.0
+	mulsd	%xmm1,%xmm3				# cos *x4
+	subsd	%xmm6,%xmm4 				# t=1.0-r
+
+	movhlps	%xmm0,%xmm1
+	subsd	%xmm2,%xmm5				# sin - 0.5 * x2 *xx
+
+	mulsd	p_temp+8(%rsp),%xmm1			# x * xx
+	movsd	.L__real_3ff0000000000000(%rip),%xmm2	# 1
+	subsd	%xmm4,%xmm2				# 1 - t
+	addsd	p_temp(%rsp),%xmm5			# sin+xx
+
+	subsd	%xmm6,%xmm2				# (1-t) - r
+	subsd	%xmm1,%xmm2				# ((1 + (-t)) - r) - x*xx
+	addsd	%xmm5,%xmm0				# sin + x
+	addsd   %xmm2,%xmm3				# cos+((1-t)-r - x*xx)
+	addsd   %xmm4,%xmm3				# cos+t
+
+	movapd	p_sign(%rsp),%xmm5		# load sign
+	movlhps %xmm3,%xmm0
+	xorpd	%xmm5,%xmm0
+	jmp .L__vrd2_sin_cleanup
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+
+.Lvrd2_cos_piby4:
+	mulpd	%xmm0,%xmm4				# x*xx
+	movdqa	.L__real_3fe0000000000000(%rip),%xmm5	# 0.5 (handle xmm5 retype)
+	movapd	.Lcosarray+0x50(%rip),%xmm1		# c6
+	movapd	.Lcosarray+0x20(%rip),%xmm0		# c3
+	mulpd	%xmm2,%xmm5				# r = 0.5 *x2
+	movapd	%xmm2,%xmm3				# copy of x2 for x4
+	movapd	 %xmm4,p_temp(%rsp)		# store x*xx
+	mulpd	%xmm2,%xmm1				# c6*x2
+	mulpd	%xmm2,%xmm0				# c3*x2
+	subpd	.L__real_3ff0000000000000(%rip),%xmm5	# -t=r-1.0
+	mulpd	%xmm2,%xmm3				# x4
+	addpd	.Lcosarray+0x40(%rip),%xmm1		# c5+x2c6
+	addpd	.Lcosarray+0x10(%rip),%xmm0		# c2+x2C3
+	addpd   .L__real_3ff0000000000000(%rip),%xmm5	# 1 + (-t)
+	mulpd	%xmm2,%xmm3				# x6
+	mulpd	%xmm2,%xmm1				# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm0				# x2(c2+x2C3)
+	movapd 	%xmm2,%xmm4				# copy of x2
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm4	# r = 0.5 *x2
+	addpd	.Lcosarray+0x30(%rip),%xmm1		# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray(%rip),%xmm0			# c1+x2(c2+x2C3)
+	mulpd	%xmm2,%xmm2				# x4
+	subpd   %xmm4,%xmm5				# (1 + (-t)) - r
+	mulpd	%xmm3,%xmm1				# x6(c4 + x2(c5+x2c6))
+	addpd	%xmm1,%xmm0				# zc
+	subpd	.L__real_3ff0000000000000(%rip),%xmm4	# -t=r-1.0
+	subpd	p_temp(%rsp),%xmm5		# ((1 + (-t)) - r) - x*xx
+	mulpd	%xmm2,%xmm0				# x4 * zc
+	addpd   %xmm5,%xmm0				# x4 * zc + ((1 + (-t)) - r -x*xx)
+	subpd   %xmm4,%xmm0				# result - (-t)
+	xorpd	p_sign(%rsp),%xmm0		# xor with sign
+	jmp 	.L__vrd2_sin_cleanup
+
+
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Llower_or_both_arg_gt_5e5:
+	cmp	%r10,%rcx				#is upper arg >= 5e5
+	jae	.Lboth_arg_gt_5e5
+
+.Llower_arg_gt_5e5:
+# Upper Arg is < 5e5, Lower arg is >= 5e5
+
+	movlpd	 %xmm0,r(%rsp)			#Save lower fp arg for remainder_piby2 call
+
+	movhlps	%xmm0,%xmm0			#Needed since we want to work on upper arg
+	movhlps	%xmm2,%xmm2
+	movhlps	%xmm4,%xmm4
+
+# Work on Upper arg
+# %xmm2,,%xmm0 xmm4 = x, xmm5 = 0.5
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+
+#If upper Arg is <=piby4
+       cmp	%rdx,%rcx					# is upper arg > piby4
+       ja	0f
+
+       mov 	 $0,%ecx						# region = 0
+       mov	 %ecx,region+4(%rsp)				# store upper region
+       movlpd	 %xmm0,r+8(%rsp)					# store upper r (unsigned - sign is adjusted later based on sign)
+       xorpd	 %xmm4,%xmm4					# rr = 0
+       movlpd	 %xmm4,rr+8(%rsp)				# store upper rr
+       jmp	.Lcheck_lower_arg
+
+#If upper Arg is > piby4
+.align 16
+0:
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm5,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm3		# xmm3 = piby2_1
+	cvttsd2si	%xmm2,%ecx				# xmm0 = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm1		# xmm1 = piby2_2
+	cvtsi2sd	%ecx,%xmm2				# xmm2 = npi2 trunc to doubles
+
+	#/* Subtract the multiple from x to get an extra-precision remainder */
+	#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm3					# npi2 * piby2_1
+	subsd	%xmm3,%xmm4					# xmm4 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+	#t  = rhead;
+       movsd	%xmm4,%xmm5					# xmm5 = t = rhead
+
+	#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm1					# xmm1 =rtail=(npi2*piby2_2)
+
+	#rhead  = t - rtail
+       subsd	%xmm1,%xmm4					# xmm4 =rhead=(t-rtail)
+
+	#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm4,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm1					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm1					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+	#r =  rhead - rtail
+	#rr = (rhead-r) -rtail
+       mov	 %ecx,region+4(%rsp)			# store upper region
+       movsd	%xmm4,%xmm0
+       subsd	%xmm1,%xmm0					# xmm0 = r=(rhead-rtail)
+       subsd	%xmm0,%xmm4					# rr=rhead-r
+       subsd	%xmm1,%xmm4					# xmm4 = rr=((rhead-r) -rtail)
+       movlpd	 %xmm0,r+8(%rsp)			# store upper r
+       movlpd	 %xmm4,rr+8(%rsp)			# store upper rr
+
+#If lower Arg is > 5e5
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+.align 16
+.Lcheck_lower_arg:
+	mov		$0x07ff0000000000000,%r9			# is lower arg nan/inf
+	mov		%r9,%r10
+	and		%rax,%r10
+	cmp		%r9,%r10
+	jz		.L__vrd2_cos_lower_naninf
+
+	mov	 %r11,p_temp(%rsp)	#Save Sign
+
+
+	lea	 region(%rsp),%rdx	# lower arg is **NOT** nan/inf
+	lea	 rr(%rsp),%rsi
+	lea	 r(%rsp),%rdi
+	movlpd	 r(%rsp),%xmm0		#Restore lower fp arg for remainder_piby2 call
+
+        call    __amd_remainder_piby2@PLT
+
+	mov	p_temp(%rsp),%r11	#Restore Sign
+
+	jmp 	.L__vrd2_sin_reconstruct
+
+.L__vrd2_cos_lower_naninf:
+	mov	r(%rsp),%rax
+	mov	$0x00008000000000000,%r9
+	or	%r9,%rax
+	mov	 %rax,r(%rsp)				# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr(%rsp)				# rr = 0
+	mov	 %r10d,region(%rsp)			# region =0
+
+	jmp 	.L__vrd2_sin_reconstruct
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lupper_arg_gt_5e5:
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+	movhpd	%xmm0,r+8(%rsp)		#Save upper fp arg for remainder_piby2 call
+	movlhps	%xmm0,%xmm0		#Not needed since we want to work on lower arg, but done just to be safe and avoide exceptions due to nan/inf and to mirror the lower_arg_gt_5e5 case
+	movlhps	%xmm2,%xmm2
+	movlhps	%xmm4,%xmm4
+
+# Work on Lower arg
+# %xmm2,,%xmm0 xmm4 = x, xmm5 = 0.5
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+
+#If lower Arg is <=piby4
+       cmp	%rdx,%rax					# is upper arg > piby4
+       ja	0f
+
+       mov 	$0,%eax						# region = 0
+       mov	 %eax,region(%rsp)			# store upper region
+       movlpd	 %xmm0,r(%rsp)				# store upper r
+       xorpd	%xmm4,%xmm4					# rr = 0
+       movlpd	 %xmm4,rr(%rsp)				# store upper rr
+       jmp .Lcheck_upper_arg
+
+.align 16
+0:
+#If upper Arg is > piby4
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm5,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm3		# xmm3 = piby2_1
+	cvttsd2si	%xmm2,%eax				# xmm0 = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm1		# xmm1 = piby2_2
+	cvtsi2sd	%eax,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm3					# npi2 * piby2_1
+	subsd	%xmm3,%xmm4					# xmm4 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm4,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm1					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm1,%xmm4					# xmm4 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm4,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm1					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm1					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %eax,region(%rsp)			# store lower region
+       movsd	%xmm4,%xmm0
+       subsd	%xmm1,%xmm0					# xmm0 = r=(rhead-rtail)
+       subsd	%xmm0,%xmm4					# rr=rhead-r
+       subsd	%xmm1,%xmm4					# xmm4 = rr=((rhead-r) -rtail)
+       movlpd	 %xmm0,r(%rsp)				# store lower r
+       movlpd	 %xmm4,rr(%rsp)				# store lower rr
+
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+.align 16
+.Lcheck_upper_arg:
+	mov		$0x07ff0000000000000,%r9			# is upper arg nan/inf
+	mov		%r9,%r10
+	and		%rcx,%r10
+	cmp		%r9,%r10
+	jz		.L__vrd2_cos_upper_naninf
+
+	mov	 %r11,p_temp(%rsp)	#Save Sign
+
+
+	lea	 region+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 rr+8(%rsp),%rsi
+	lea	 r+8(%rsp),%rdi
+	movlpd	 r+8(%rsp),%xmm0	#Restore upper fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+
+	mov	p_temp(%rsp),%r11	#Restore Sign
+
+	jmp .L__vrd2_sin_reconstruct
+
+.L__vrd2_cos_upper_naninf:
+	mov	r+8(%rsp),%rcx				# upper arg is nan/inf
+	mov	$0x00008000000000000,%r9
+	or	%r9,%rcx
+	mov	%rcx,r+8(%rsp)				# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	%r10,rr+8(%rsp)				# rr = 0
+	mov	%r10d,region+4(%rsp)			# region =0
+	jmp 	.L__vrd2_sin_reconstruct
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lboth_arg_gt_5e5:
+#Upper Arg is >= 5e5, Lower arg is >= 5e5
+
+	movhpd	 %xmm0,p_temp2(%rsp) 			#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r9	#is lower arg nan/inf
+	mov		%r9,%r10
+	and		%rax,%r10
+	cmp		%r9,%r10
+	jz		.L__vrd2_cos_lower_naninf_of_both_gt_5e5
+
+	mov	  %rcx,p_temp(%rsp)			#Save upper arg
+	mov	  %r11,p_temp1(%rsp)			#Save Sign
+
+	lea	 region(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	 rr(%rsp),%rsi
+	lea	 r(%rsp),%rdi
+        call    __amd_remainder_piby2@PLT
+
+	mov	 p_temp1(%rsp),%r11			#Restore Sign
+	mov	 p_temp(%rsp),%rcx			#Restore upper arg
+	jmp 	0f
+
+.L__vrd2_cos_lower_naninf_of_both_gt_5e5:				#lower arg is nan/inf
+	movd	%xmm0,%rax
+	mov	$0x00008000000000000,%r9
+	or	%r9,%rax
+	mov	%rax,r(%rsp)				#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	%r10,rr(%rsp)				#rr = 0
+	mov	%r10d,region(%rsp)			#region = 0
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r9			#is upper arg nan/inf
+	mov		%r9,%r10
+	and		%rcx,%r10
+	cmp		%r9,%r10
+	jz		.L__vrd2_cos_upper_naninf_of_both_gt_5e5
+
+
+	mov	 %r11,p_temp(%rsp)	#Save Sign
+
+	lea	 region+4(%rsp),%rdx		#upper arg is **NOT** nan/inf
+	lea	 rr+8(%rsp),%rsi
+	lea	 r+8(%rsp),%rdi
+	movlpd	 p_temp2(%rsp),%xmm0		#Restore upper fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+
+	mov	p_temp(%rsp),%r11	#Restore Sign
+
+	jmp 	0f
+
+.L__vrd2_cos_upper_naninf_of_both_gt_5e5:
+	mov	 p_temp2(%rsp),%rcx			#upper arg is nan/inf
+	mov	 $0x00008000000000000,%r9
+	or	 %r9,%rcx
+	mov	 %rcx,r+8(%rsp)				#r = x | 0x0008000000000000
+	xor	 %r10,%r10
+	mov	 %r10,rr+8(%rsp)			#rr = 0
+	mov	 %r10d,region+4(%rsp)			#region = 0
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+0:
+.L__vrd2_sin_reconstruct:
+#Construct xmm0=x, xmm2 =x2, xmm4=xx, r8=region, xmm6=sign
+	movapd	r(%rsp),%xmm0				#x
+	movapd	%xmm0,%xmm2				#move for x2
+	mulpd	%xmm2,%xmm2				#x2
+	movapd	rr(%rsp),%xmm4				#xx
+
+	mov	region(%rsp),%r8
+	mov 	.L__reald_one_zero(%rip),%r9		#compare value for cossin path
+	mov 	%r8,%r10
+	and	.L__reald_one_one(%rip),%r8		#odd/even region for cos/sin
+
+	shr	$1,%r10					#~AB+A~B, A is sign and B is upper bit of region
+	mov	%r10,%rcx
+	not 	%r11					#ADDED TO CHANGE THE LOGIC
+	and	%r11,%r10
+	not	%rcx
+	not	%r11
+	and	%r11,%rcx
+	or	%rcx,%r10
+	and	.L__reald_one_one(%rip),%r10		#(~AB+A~B)&1
+
+	mov	%r10,%r11
+	and	%r9,%r11				#mask out the lower sign bit leaving the upper sign bit
+	shl	$63,%r10				#shift lower sign bit left by 63 bits
+	shl	$31,%r11				#shift upper sign bit left by 31 bits
+	mov 	 %r10,p_sign(%rsp)			#write out lower sign bit
+	mov 	 %r11,p_sign+8(%rsp)			#write out upper sign bit
+
+	jmp .L__vrd2_sin_approximate
+#ENDMAIN
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrd2_sin_cleanup:
+	add	$0x138,%rsp
+	ret
+
diff --git a/src/gas/vrd2sincos.S b/src/gas/vrd2sincos.S
new file mode 100644
index 0000000..b25bb37
--- /dev/null
+++ b/src/gas/vrd2sincos.S
@@ -0,0 +1,968 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# A vector implementation of the libm sincos function.
+#
+# Prototype:
+#
+#     __vrd2_sincos(__m128d x, __m128d* ys, __m128d* yc);
+#
+#   Computes Sine and Cosine of x.
+#   It will provide proper C99 return values,
+#   but may not raise floating point status bits properly.
+#   Based on the NAG C implementation.
+#   Author: Harsha Jagasia
+#   Email:  harsha.jagasia@amd.com
+
+
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+
+.data
+.align 16
+.L__real_7fffffffffffffff: 	.quad 0x07fffffffffffffff	#Sign bit zero
+				.quad 0x07fffffffffffffff
+.L__real_3ff0000000000000: 	.quad 0x03ff0000000000000	# 1.0
+				.quad 0x03ff0000000000000
+.L__real_v2p__27:		.quad 0x03e40000000000000	# 2p-27
+				.quad 0x03e40000000000000
+.L__real_3fe0000000000000: 	.quad 0x03fe0000000000000	# 0.5
+				.quad 0x03fe0000000000000
+.L__real_3fc5555555555555: 	.quad 0x03fc5555555555555	# 0.166666666666
+				.quad 0x03fc5555555555555
+.L__real_3fe45f306dc9c883: 	.quad 0x03fe45f306dc9c883	# twobypi
+				.quad 0x03fe45f306dc9c883
+.L__real_3ff921fb54400000: 	.quad 0x03ff921fb54400000	# piby2_1
+				.quad 0x03ff921fb54400000
+.L__real_3dd0b4611a626331: 	.quad 0x03dd0b4611a626331	# piby2_1tail
+				.quad 0x03dd0b4611a626331
+.L__real_3dd0b4611a600000: 	.quad 0x03dd0b4611a600000	# piby2_2
+				.quad 0x03dd0b4611a600000
+.L__real_3ba3198a2e037073: 	.quad 0x03ba3198a2e037073	# piby2_2tail
+				.quad 0x03ba3198a2e037073
+.L__real_fffffffff8000000: 	.quad 0x0fffffffff8000000	# mask for stripping head and tail
+				.quad 0x0fffffffff8000000
+.L__real_8000000000000000:	.quad 0x08000000000000000	# -0  or signbit
+				.quad 0x08000000000000000
+.L__reald_one_one:		.quad 0x00000000100000001	#
+				.quad 0
+.L__reald_two_two:		.quad 0x00000000200000002	#
+				.quad 0
+.L__reald_one_zero:		.quad 0x00000000100000000	# sin_cos_filter
+				.quad 0
+.L__reald_zero_one:		.quad 0x00000000000000001	#
+				.quad 0
+.L__reald_two_zero:		.quad 0x00000000200000000	#
+				.quad 0
+.L__realq_one_one:		.quad 0x00000000000000001	#
+				.quad 0x00000000000000001	#
+.L__realq_two_two:		.quad 0x00000000000000002	#
+				.quad 0x00000000000000002	#
+.L__real_1_x_mask:		.quad 0x0ffffffffffffffff	#
+				.quad 0x03ff0000000000000	#
+.L__real_zero:			.quad 0x00000000000000000	#
+				.quad 0x00000000000000000	#
+.L__real_one:			.quad 0x00000000000000001	#
+				.quad 0x00000000000000001	#
+.L__real_ffffffffffffffff: 	.quad 0x0ffffffffffffffff	#Sign bit one
+				.quad 0x0ffffffffffffffff
+.L__real_naninf_upper_sign_mask:	.quad 0x000000000ffffffff	#
+					.quad 0x000000000ffffffff	#
+.L__real_naninf_lower_sign_mask:	.quad 0x0ffffffff00000000	#
+					.quad 0x0ffffffff00000000	#
+
+.Lcosarray:
+	.quad	0x03fa5555555555555		#  0.0416667		   	c1
+	.quad	0x03fa5555555555555
+	.quad	0x0bf56c16c16c16967		# -0.00138889	   		c2
+	.quad	0x0bf56c16c16c16967
+	.quad	0x03efa01a019f4ec90		#  2.48016e-005			c3
+	.quad	0x03efa01a019f4ec90
+	.quad	0x0be927e4fa17f65f6		# -2.75573e-007			c4
+	.quad	0x0be927e4fa17f65f6
+	.quad	0x03e21eeb69037ab78		#  2.08761e-009			c5
+	.quad	0x03e21eeb69037ab78
+	.quad	0x0bda907db46cc5e42		# -1.13826e-011	   		c6
+	.quad	0x0bda907db46cc5e42
+.Lsinarray:
+	.quad	0x0bfc5555555555555		# -0.166667	   		s1
+	.quad	0x0bfc5555555555555
+	.quad	0x03f81111111110bb3		#  0.00833333	   		s2
+	.quad	0x03f81111111110bb3
+	.quad	0x0bf2a01a019e83e5c		# -0.000198413			s3
+	.quad	0x0bf2a01a019e83e5c
+	.quad	0x03ec71de3796cde01		#  2.75573e-006			s4
+	.quad	0x03ec71de3796cde01
+	.quad	0x0be5ae600b42fdfa7		# -2.50511e-008			s5
+	.quad	0x0be5ae600b42fdfa7
+	.quad	0x03de5e0b2f9a43bb8		#  1.59181e-010	   		s6
+	.quad	0x03de5e0b2f9a43bb8
+.Lsincosarray:
+	.quad	0x0bfc5555555555555		# -0.166667	   		s1
+	.quad	0x03fa5555555555555		#  0.0416667		   	c1
+	.quad	0x03f81111111110bb3		#  0.00833333	   		s2
+	.quad	0x0bf56c16c16c16967		#				c2
+	.quad	0x0bf2a01a019e83e5c		# -0.000198413			s3
+	.quad	0x03efa01a019f4ec90
+	.quad	0x03ec71de3796cde01		#  2.75573e-006			s4
+	.quad	0x0be927e4fa17f65f6
+	.quad	0x0be5ae600b42fdfa7		# -2.50511e-008			s5
+	.quad	0x03e21eeb69037ab78
+	.quad	0x03de5e0b2f9a43bb8		#  1.59181e-010	   		s6
+	.quad	0x0bda907db46cc5e42
+.Lcossinarray:
+	.quad	0x03fa5555555555555		#  0.0416667		   	c1
+	.quad	0x0bfc5555555555555		# -0.166667	   		s1
+	.quad	0x0bf56c16c16c16967		#				c2
+	.quad	0x03f81111111110bb3		#  0.00833333	   		s2
+	.quad	0x03efa01a019f4ec90
+	.quad	0x0bf2a01a019e83e5c		# -0.000198413			s3
+	.quad	0x0be927e4fa17f65f6
+	.quad	0x03ec71de3796cde01		#  2.75573e-006			s4
+	.quad	0x03e21eeb69037ab78
+	.quad	0x0be5ae600b42fdfa7		# -2.50511e-008			s5
+	.quad	0x0bda907db46cc5e42
+	.quad	0x03de5e0b2f9a43bb8		#  1.59181e-010	   		s6
+
+
+.text
+.align 16
+.p2align 4,,15
+
+.equ	p_temp,		0x00		# temporary for get/put bits operation
+.equ	p_temp1,	0x10		# temporary for get/put bits operation
+.equ	p_temp2,	0x20		# temporary for get/put bits operation
+
+.equ	save_xmm6,	0x30		# temporary for get/put bits operation
+.equ	save_xmm7,	0x40		# temporary for get/put bits operation
+.equ	save_xmm8,	0x50		# temporary for get/put bits operation
+.equ	save_xmm9,	0x60		# temporary for get/put bits operation
+.equ	save_xmm10,	0x70		# temporary for get/put bits operation
+.equ	save_xmm11,	0x80		# temporary for get/put bits operation
+.equ	save_xmm12,	0x90		# temporary for get/put bits operation
+.equ	save_xmm13,	0x0A0		# temporary for get/put bits operation
+.equ	save_xmm14,	0x0B0		# temporary for get/put bits operation
+.equ	save_xmm15,	0x0C0		# temporary for get/put bits operation
+
+.equ	save_rdi,	0x0D0
+.equ	save_rsi,	0x0E0
+
+.equ	r,		0x0F0		# pointer to r for remainder_piby2
+.equ	rr,		0x0100		# pointer to r for remainder_piby2
+.equ	region,		0x0110		# pointer to r for remainder_piby2
+
+.equ	p_original,	0x0120		# original x
+.equ	p_mask,		0x0130		# original x
+.equ	p_sign,		0x0140		# original x
+.equ	p_sign1,	0x0150		# original x
+.equ	p_x,		0x0160		#x
+.equ	p_xx,		0x0170		#xx
+.equ	p_x2,		0x0180		#x2
+.equ	p_sin,		0x0190		#sin
+.equ	p_cos,		0x01A0		#cos
+.equ	p_temp2,	0x01B0		# temporary for get/put bits operation
+
+.globl __vrd2_sincos
+    .type   __vrd2_sincos,@function
+__vrd2_sincos:
+	sub		$0x1C8,%rsp
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#STARTMAIN
+
+movdqa 	%xmm0,%xmm6				#move to mem to get into integer regs **
+movdqa  %xmm0, p_original(%rsp)			#move to mem to get into integer regs -
+
+andpd 	.L__real_7fffffffffffffff(%rip),%xmm0		#Unsign			-
+
+mov	%rdi, p_sin(%rsp)		# save address for sin return
+mov	%rsi, p_cos(%rsp)		# save address for cos return
+
+movd	%xmm0,%rax				#rax is lower arg
+movhpd	%xmm0, p_temp+8(%rsp)			#
+mov    	p_temp+8(%rsp),%rcx			#rcx = upper arg
+movdqa	%xmm0,%xmm8
+
+pcmpgtd		%xmm6,%xmm8
+movdqa		%xmm8,%xmm6
+psrldq		$4,%xmm8
+psrldq		$8,%xmm6
+
+mov 	$0x3FE921FB54442D18,%rdx			#piby4
+mov	$0x411E848000000000,%r10			#5e5
+movapd	.L__real_3fe0000000000000(%rip),%xmm4			#0.5 for later use
+
+por	%xmm6,%xmm8
+movd	%xmm8,%r11				#Move Sign to gpr **
+
+movapd	%xmm0,%xmm2				#x
+movapd	%xmm0,%xmm6				#x
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Leither_or_both_arg_gt_than_piby4:
+
+	cmp	%r10,%rax				#is lower arg >= 5e5
+	jae	.Llower_or_both_arg_gt_5e5
+	cmp	%r10,%rcx				#is upper arg >= 5e5
+	jae	.Lupper_arg_gt_5e5
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lboth_arg_lt_than_5e5:
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# * twobypi
+	addpd	%xmm4,%xmm2					# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm0		# piby2_1
+	cvttpd2dq	%xmm2,%xmm4				# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	cvtdq2pd	%xmm4,%xmm2				# and back to double.
+
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+
+	movd	%xmm4,%r8						# Region
+
+	mov 	.L__reald_one_zero(%rip),%rdx			#compare value for cossin path
+	mov	%r8,%r10
+	mov	%r8,%rcx
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm0						# npi2 * piby2_1;
+
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm0,%xmm6						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm0						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm0						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+       subpd	%xmm0,%xmm6						# t-rhead
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm4  = npi2 (int), xmm0 =rhead, xmm8 =rtail
+
+	and	.L__reald_one_one(%rip),%r8			#odd/even region for cos/sin
+
+	shr	$1,%r10						#~AB+A~B, A is sign and B is upper bit of region
+	mov	%r10,%rax
+	not 	%r11						#ADDED TO CHANGE THE LOGIC
+	and	%r11,%r10
+	not	%rax
+	not	%r11
+	and	%r11,%rax
+	or	%rax,%r10
+	and	.L__reald_one_one(%rip),%r10				#(~AB+A~B)&1
+	mov	%r10,%r11
+	and	%rdx,%r11				#mask out the lower sign bit leaving the upper sign bit
+	shl	$63,%r10				#shift lower sign bit left by 63 bits
+	shl	$31,%r11				#shift upper sign bit left by 31 bits
+	mov 	 %r10,p_sign(%rsp)		#write out lower sign bit
+	mov 	 %r11,p_sign+8(%rsp)		#write out upper sign bit
+
+# xmm4  = Sign, xmm0 =rhead, xmm8 =rtail
+
+	movapd	%xmm0,%xmm6						# rhead
+	subpd	%xmm8,%xmm0						# r = rhead - rtail
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm4  = Sign, xmm0 = r, xmm6 =rhead, xmm8 =rtail
+
+	subpd	%xmm0,%xmm6				#rr=rhead-r
+	movapd	%xmm0,%xmm2				#move r for r2
+	mulpd	%xmm0,%xmm2				#r2
+	subpd	%xmm8,%xmm6				#rr=(rhead-r) -rtail
+
+	mov 	.L__reald_one_zero(%rip),%r9		# Compare value for cossin	+
+
+
+	add	.L__reald_one_one(%rip),%rcx
+	and	.L__reald_two_two(%rip),%rcx
+	shr	$1,%rcx
+
+	mov	%rcx,%rdx
+	and	%r9,%rdx				#mask out the lower sign bit leaving the upper sign bit
+	shl	$63,%rcx				#shift lower sign bit left by 63 bits
+	shl	$31,%rdx				#shift upper sign bit left by 31 bits
+	mov 	 %rcx,p_sign1(%rsp)		#write out lower sign bit
+	mov 	 %rdx,p_sign1+8(%rsp)		#write out upper sign bit
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+.align 16
+.L__vrd2_sincos_approximate:
+	cmp 	$0,%r8
+	jnz	.Lvrd2_not_sin_piby4
+
+.Lvrd2_sin_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+
+	movdqa	.Lcosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lsinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lcosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lsinarray+0x20(%rip),%xmm9			# c3
+
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm2,%xmm11					# x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm2,%xmm5					# c6*x2
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm2,%xmm9					# c3*x2
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10	# r = 0.5 *x2
+	movapd	 %xmm2,p_temp(%rsp)			# store x2
+
+	addpd	.Lcosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsinarray+0x40(%rip),%xmm5			# c5+x2c6
+	movapd	 %xmm10,p_temp2(%rsp)			# store r
+	addpd	.Lcosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0
+	mulpd	%xmm2,%xmm11					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm5					# x2(c5+x2c6)
+	movapd	 %xmm10,p_temp1(%rsp) 			# store t
+	movapd	%xmm11,%xmm3					# Keep x4
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm2,%xmm9					# x2(c2+x2C3)
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t)
+	mulpd	%xmm2,%xmm11					# x6
+
+	addpd	.Lcosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lsinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	subpd   p_temp2(%rsp),%xmm10			# (1 + (-t)) - r
+	mulpd	%xmm0,%xmm2					# x3 recalculate
+
+	mulpd	%xmm11,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm11,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	movapd	%xmm0,%xmm1
+	movapd	%xmm6,%xmm7
+	mulpd	%xmm6,%xmm1					# x*xx
+	mulpd	p_temp2(%rsp),%xmm7			# xx * 0.5x2
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zs
+
+	subpd   %xmm1,%xmm10					# ((1 + (-t)) - r) -x*xx
+
+	mulpd	%xmm3,%xmm4					# x4 * zc
+	mulpd	%xmm2,%xmm5					# x3 * zs
+
+	addpd	%xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	subpd	%xmm7,%xmm5					# x3*zs - 0.5 * x2 *xx
+
+	addpd	%xmm6,%xmm5					# sin + xx
+	subpd	p_temp1(%rsp),%xmm4			# cos - (-t)
+	addpd	%xmm0,%xmm5					# sin + x
+
+	jmp 	.L__vrd2_sincos_cleanup
+
+.align 16
+.Lvrd2_not_sin_piby4:
+	cmp 	.L__reald_one_one(%rip),%r8
+	jnz	.Lvrd2_not_cos_piby4
+
+.Lvrd2_cos_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+
+	movdqa	.Lcosarray+0x50(%rip),%xmm5			# c6
+	movdqa	.Lsinarray+0x50(%rip),%xmm4			# c6
+	movapd	.Lcosarray+0x20(%rip),%xmm9			# c3
+	movapd	.Lsinarray+0x20(%rip),%xmm8			# c3
+
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm2,%xmm11					# x2
+
+	mulpd	%xmm2,%xmm5					# c6*x2
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm2,%xmm9					# c3*x2
+	mulpd	%xmm2,%xmm8					# c3*x2
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10	# r = 0.5 *x2
+	movapd	 %xmm2,p_temp(%rsp)			# store x2
+
+	addpd	.Lcosarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lsinarray+0x40(%rip),%xmm4			# c5+x2c6
+	movapd	 %xmm10,p_temp2(%rsp)			# store r
+	addpd	.Lcosarray+0x10(%rip),%xmm9			# c2+x2C3
+	addpd	.Lsinarray+0x10(%rip),%xmm8			# c2+x2C3
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0
+	mulpd	%xmm2,%xmm11					# x4
+
+	mulpd	%xmm2,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	movapd	 %xmm10,p_temp1(%rsp) 			# store t
+	movapd	%xmm11,%xmm3					# Keep x4
+	mulpd	%xmm2,%xmm9					# x2(c2+x2C3)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t)
+	mulpd	%xmm2,%xmm11					# x6
+
+	addpd	.Lcosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+	addpd	.Lsinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+
+	subpd   p_temp2(%rsp),%xmm10			# (1 + (-t)) - r
+	mulpd	%xmm0,%xmm2					# x3 recalculate
+
+	mulpd	%xmm11,%xmm5					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm11,%xmm4					# x6(c4 + x2(c5+x2c6))
+
+	movapd	%xmm0,%xmm1
+	movapd	%xmm6,%xmm7
+	mulpd	%xmm6,%xmm1					# x*xx
+	mulpd	p_temp2(%rsp),%xmm7			# xx * 0.5x2
+
+	addpd	%xmm9,%xmm5					# zc
+	addpd	%xmm8,%xmm4					# zs
+
+	subpd   %xmm1,%xmm10					# ((1 + (-t)) - r) -x*xx
+
+	mulpd	%xmm3,%xmm5					# x4 * zc
+	mulpd	%xmm2,%xmm4					# x3 * zs
+
+	addpd	%xmm10,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	subpd	%xmm7,%xmm4					# x3*zs - 0.5 * x2 *xx
+
+	addpd	%xmm6,%xmm4					# sin + xx
+	subpd	p_temp1(%rsp),%xmm5			# cos - (-t)
+	addpd	%xmm0,%xmm4					# sin + x
+
+	jmp 	.L__vrd2_sincos_cleanup
+
+.align 16
+.Lvrd2_not_cos_piby4:
+	cmp 	$1,%r8
+	jnz	.Lvrd2_cossin_piby4
+
+.Lvrd2_sincos_piby4:
+	movdqa	.Lcosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lsinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lcosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lsinarray+0x20(%rip),%xmm9			# c3
+
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm2,%xmm11					# x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm2,%xmm5					# c6*x2
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm2,%xmm9					# c3*x2
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10	# r = 0.5 *x2
+	movapd	 %xmm2,p_temp(%rsp)			# store x2
+
+	addpd	.Lcosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsinarray+0x40(%rip),%xmm5			# c5+x2c6
+	movapd	 %xmm10,p_temp2(%rsp)			# store r
+	addpd	.Lcosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0
+	mulpd	%xmm2,%xmm11					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm5					# x2(c5+x2c6)
+	movapd	 %xmm10,p_temp1(%rsp) 			# store t
+	movapd	%xmm11,%xmm3					# Keep x4
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm2,%xmm9					# x2(c2+x2C3)
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t)
+	mulpd	%xmm2,%xmm11					# x6
+
+	addpd	.Lcosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lsinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	subpd   p_temp2(%rsp),%xmm10			# (1 + (-t)) - r
+	mulpd	%xmm0,%xmm2					# x3 recalculate
+
+	mulpd	%xmm11,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm11,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	movapd	%xmm0,%xmm1
+	movapd	%xmm6,%xmm7
+	mulpd	%xmm6,%xmm1					# x*xx
+	mulpd	p_temp2(%rsp),%xmm7			# xx * 0.5x2
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zs
+
+	subpd   %xmm1,%xmm10					# ((1 + (-t)) - r) -x*xx
+
+	mulpd	%xmm3,%xmm4					# x4 * zc
+	mulpd	%xmm2,%xmm5					# x3 * zs
+
+	addpd	%xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	subpd	%xmm7,%xmm5					# x3*zs - 0.5 * x2 *xx
+
+	addpd	%xmm6,%xmm5					# sin + xx
+	subpd	p_temp1(%rsp),%xmm4			# cos - (-t)
+	addpd	%xmm0,%xmm5					# sin + x
+
+	movsd	%xmm4,%xmm1
+	movsd	%xmm5,%xmm4
+	movsd	%xmm1,%xmm5
+
+	jmp 	.L__vrd2_sincos_cleanup
+
+.align 16
+.Lvrd2_cossin_piby4:
+	movdqa	.Lcosarray+0x50(%rip),%xmm5			# c6
+	movdqa	.Lsinarray+0x50(%rip),%xmm4			# c6
+	movapd	.Lcosarray+0x20(%rip),%xmm9			# c3
+	movapd	.Lsinarray+0x20(%rip),%xmm8			# c3
+
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm2,%xmm11					# x2
+
+	mulpd	%xmm2,%xmm5					# c6*x2
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm2,%xmm9					# c3*x2
+	mulpd	%xmm2,%xmm8					# c3*x2
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10	# r = 0.5 *x2
+	movapd	 %xmm2,p_temp(%rsp)			# store x2
+
+	addpd	.Lcosarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lsinarray+0x40(%rip),%xmm4			# c5+x2c6
+	movapd	 %xmm10,p_temp2(%rsp)			# store r
+	addpd	.Lcosarray+0x10(%rip),%xmm9			# c2+x2C3
+	addpd	.Lsinarray+0x10(%rip),%xmm8			# c2+x2C3
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0
+	mulpd	%xmm2,%xmm11					# x4
+
+	mulpd	%xmm2,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	movapd	 %xmm10,p_temp1(%rsp) 			# store t
+	movapd	%xmm11,%xmm3					# Keep x4
+	mulpd	%xmm2,%xmm9					# x2(c2+x2C3)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t)
+	mulpd	%xmm2,%xmm11					# x6
+
+	addpd	.Lcosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+	addpd	.Lsinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+
+	subpd   p_temp2(%rsp),%xmm10			# (1 + (-t)) - r
+	mulpd	%xmm0,%xmm2					# x3 recalculate
+
+	mulpd	%xmm11,%xmm5					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm11,%xmm4					# x6(c4 + x2(c5+x2c6))
+
+	movapd	%xmm0,%xmm1
+	movapd	%xmm6,%xmm7
+	mulpd	%xmm6,%xmm1					# x*xx
+	mulpd	p_temp2(%rsp),%xmm7			# xx * 0.5x2
+
+	addpd	%xmm9,%xmm5					# zc
+	addpd	%xmm8,%xmm4					# zs
+
+	subpd   %xmm1,%xmm10					# ((1 + (-t)) - r) -x*xx
+
+	mulpd	%xmm3,%xmm5					# x4 * zc
+	mulpd	%xmm2,%xmm4					# x3 * zs
+
+	addpd	%xmm10,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	subpd	%xmm7,%xmm4					# x3*zs - 0.5 * x2 *xx
+
+	addpd	%xmm6,%xmm4					# sin + xx
+	subpd	p_temp1(%rsp),%xmm5			# cos - (-t)
+	addpd	%xmm0,%xmm4					# sin + x
+
+	movsd	%xmm5,%xmm1
+	movsd	%xmm4,%xmm5
+	movsd	%xmm1,%xmm4
+
+	jmp 	.L__vrd2_sincos_cleanup
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Llower_or_both_arg_gt_5e5:
+	cmp	%r10,%rcx				#is upper arg >= 5e5
+	jae	.Lboth_arg_gt_5e5
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Llower_arg_gt_5e5:
+# Upper Arg is < 5e5, Lower arg is >= 5e5
+
+	movlpd	 %xmm0,r(%rsp)		#Save lower fp arg for remainder_piby2 call
+
+	movhlps	%xmm0,%xmm0			#Needed since we want to work on upper arg
+	movhlps	%xmm2,%xmm2
+	movhlps	%xmm6,%xmm6
+
+# Work on Upper arg
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+
+#If upper Arg is <=piby4
+       cmp	%rdx,%rcx					# is upper arg > piby4
+       ja	0f
+
+       mov 	$0,%ecx						# region = 0
+       mov	 %ecx,region+4(%rsp)			# store upper region
+       movlpd	 %xmm0,r+8(%rsp)			# store upper r (unsigned - sign is adjusted later based on sign)
+       xorpd	%xmm4,%xmm4					# rr = 0
+       movlpd	 %xmm4,rr+8(%rsp)			# store upper rr
+       jmp	.Lcheck_lower_arg
+
+#If upper Arg is > piby4
+.align 16
+0:
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm4,%xmm2					# npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm3		# piby2_1
+	cvttsd2si	%xmm2,%ecx				# npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm1		# piby2_2
+	cvtsi2sd	%ecx,%xmm2				# npi2 trunc to doubles
+
+	#/* Subtract the multiple from x to get an extra-precision remainder */
+	#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm3					# npi2 * piby2_1
+	subsd	%xmm3,%xmm6					# rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm8		# piby2_2tail
+
+	#t  = rhead;
+       movsd	%xmm6,%xmm5					# t = rhead
+
+	#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm1					# rtail=(npi2*piby2_2)
+
+	#rhead  = t - rtail
+       subsd	%xmm1,%xmm6					# rhead=(t-rtail)
+
+	#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm8     					# npi2 * piby2_2tail
+       subsd	%xmm6,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm1					# (rtail-(t-rhead))
+       addsd	%xmm8,%xmm1					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+	#r =  rhead - rtail
+	#rr = (rhead-r) -rtail
+       mov	 %ecx,region+4(%rsp)			# store upper region
+       movsd	%xmm6,%xmm0
+       subsd	%xmm1,%xmm0					# r=(rhead-rtail)
+
+       subsd	%xmm0,%xmm6					# rr=rhead-r
+       subsd	%xmm1,%xmm6					# xmm4 = rr=((rhead-r) -rtail)
+
+       movlpd	 %xmm0,r+8(%rsp)			# store upper r
+       movlpd	 %xmm6,rr+8(%rsp)			# store upper rr
+
+#If lower Arg is > 5e5
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+.align 16
+.Lcheck_lower_arg:
+	mov		$0x07ff0000000000000,%r9			# is lower arg nan/inf
+	mov		%r9,%r10
+	and		%rax,%r10
+	cmp		%r9,%r10
+	jz		.L__vrd2_cos_lower_naninf
+
+	lea	 region(%rsp),%rdx			# lower arg is **NOT** nan/inf
+	lea	 rr(%rsp),%rsi
+	lea	 r(%rsp),%rdi
+	movlpd	 r(%rsp),%xmm0				#Restore lower fp arg for remainder_piby2 call
+	mov	 %r11,p_temp(%rsp)			#Save Sign
+        call    __amd_remainder_piby2@PLT
+	mov	p_temp(%rsp),%r11			#Restore Sign
+
+	jmp 	.L__vrd2_cos_reconstruct
+
+.L__vrd2_cos_lower_naninf:
+	mov	p_original(%rsp),%rax			# upper arg is nan/inf
+
+	mov	$0x00008000000000000,%r9
+	or	%r9,%rax
+	mov	 %rax,r(%rsp)				# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr(%rsp)				# rr = 0
+	mov	 %r10d,region(%rsp)			# region =0
+	and 	.L__real_naninf_lower_sign_mask(%rip),%r11	# Sign
+
+	jmp 	.L__vrd2_cos_reconstruct
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lupper_arg_gt_5e5:
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+	movhpd	 %xmm0,r+8(%rsp)		#Save upper fp arg for remainder_piby2 call
+#	movlhps	%xmm0,%xmm0				;Not needed since we want to work on lower arg, but done just to be safe and avoide exceptions due to nan/inf and to mirror the lower_arg_gt_5e5 case
+#	movlhps	%xmm2,%xmm2
+#	movlhps	%xmm6,%xmm6
+
+# Work on Lower arg
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+
+#If lower Arg is <=piby4
+       cmp	%rdx,%rax					# is upper arg > piby4
+       ja	0f
+
+       mov 	$0,%eax						# region = 0
+       mov	 %eax,region(%rsp)			# store upper region
+       movlpd	 %xmm0,r(%rsp)				# store upper r
+       xorpd	%xmm4,%xmm4					# rr = 0
+       movlpd	 %xmm4,rr(%rsp)				# store upper rr
+       jmp 	.Lcheck_upper_arg
+
+.align 16
+0:
+#If upper Arg is > piby4
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm4,%xmm2					# npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm3		# piby2_1
+	cvttsd2si	%xmm2,%eax				# npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm1		# piby2_2
+	cvtsi2sd	%eax,%xmm2				# npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm3					# npi2 * piby2_1;
+	subsd	%xmm3,%xmm6					# rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm8		# piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm6,%xmm5					# t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm1					# rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm1,%xmm6					# rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm8     					# npi2 * piby2_2tail
+       subsd	%xmm6,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm1					# (rtail-(t-rhead))
+       addsd	%xmm8,%xmm1					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %eax,region(%rsp)			# store lower region
+       movsd	%xmm6,%xmm0
+       subsd	%xmm1,%xmm0					# r=(rhead-rtail)
+       subsd	%xmm0,%xmm6					# rr=rhead-r
+       subsd	%xmm1,%xmm6					# rr=((rhead-r) -rtail)
+       movlpd	 %xmm0,r(%rsp)				# store lower r
+       movlpd	 %xmm6,rr(%rsp)				# store lower rr
+
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+.align 16
+.Lcheck_upper_arg:
+	mov		$0x07ff0000000000000,%r9			# is upper arg nan/inf
+	mov		%r9,%r10
+	and		%rcx,%r10
+	cmp		%r9,%r10
+	jz		.L__vrd2_cos_upper_naninf
+
+	lea	 region+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 rr+8(%rsp),%rsi
+	lea	 r+8(%rsp),%rdi
+	movlpd	 r+8(%rsp),%xmm0	#Restore upper fp arg for remainder_piby2 call
+	mov	 %r11,p_temp(%rsp)	#Save Sign
+        call    __amd_remainder_piby2@PLT
+	mov	p_temp(%rsp),%r11	#Restore Sign
+
+	jmp 	.L__vrd2_cos_reconstruct
+
+.L__vrd2_cos_upper_naninf:
+	mov	p_original+8(%rsp),%rcx		# upper arg is nan/inf
+	mov	$0x00008000000000000,%r9
+	or	%r9,%rcx
+	mov	 %rcx,r+8(%rsp)					# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr+8(%rsp)					# rr = 0
+	mov	 %r10d,region+4(%rsp)				# region =0
+	and 	.L__real_naninf_upper_sign_mask(%rip),%r11	# Sign
+	jmp 	.L__vrd2_cos_reconstruct
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lboth_arg_gt_5e5:
+#Upper Arg is >= 5e5, Lower arg is >= 5e5
+
+	movhpd	%xmm0,  p_temp2(%rsp) 				#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r9			#is lower arg nan/inf
+	mov		%r9,%r10
+	and		%rax,%r10
+	cmp		%r9,%r10
+	jz		.L__vrd2_cos_lower_naninf_of_both_gt_5e5
+
+	lea	 region(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	 rr(%rsp),%rsi
+	lea	 r(%rsp),%rdi
+	mov	  %rcx,p_temp(%rsp)			#Save upper arg
+	mov	  %r11,p_temp1(%rsp)	#Save Sign
+        call    __amd_remainder_piby2@PLT
+	mov	 p_temp1(%rsp),%r11	#Restore Sign
+	mov	 p_temp(%rsp),%rcx			#Restore upper arg
+	jmp 	0f
+
+.L__vrd2_cos_lower_naninf_of_both_gt_5e5:				#lower arg is nan/inf
+	mov	p_original(%rsp),%rax
+	mov	$0x00008000000000000,%r9
+	or	%r9,%rax
+	mov	 %rax,r(%rsp)				#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr(%rsp)				#rr = 0
+	mov	 %r10d,region(%rsp)			#region = 0
+	and 	.L__real_naninf_lower_sign_mask(%rip),%r11	# Sign
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r9			#is upper arg nan/inf
+	mov		%r9,%r10
+	and		%rcx,%r10
+	cmp		%r9,%r10
+	jz		.L__vrd2_cos_upper_naninf_of_both_gt_5e5
+
+	lea	 region+4(%rsp),%rdx			#upper arg is **NOT** nan/inf
+	lea	 rr+8(%rsp),%rsi
+	lea	 r+8(%rsp),%rdi
+	movlpd	 p_temp2(%rsp), %xmm0			#Restore upper fp arg for remainder_piby2 call
+	mov	 %r11,p_temp(%rsp)	#Save Sign
+        call    __amd_remainder_piby2@PLT
+	mov	 p_temp(%rsp),%r11	#Restore Sign
+
+	jmp 	0f
+
+.L__vrd2_cos_upper_naninf_of_both_gt_5e5:
+	mov	p_original+8(%rsp),%rcx		#upper arg is nan/inf
+	mov	$0x00008000000000000,%r9
+	or	%r9,%rcx
+	mov	%rcx,r+8(%rsp)					#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	%r10,rr+8(%rsp)					#rr = 0
+	mov	%r10d,region+4(%rsp)				#region = 0
+	and 	.L__real_naninf_upper_sign_mask(%rip),%r11	# Sign
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+0:
+.L__vrd2_cos_reconstruct:
+#Construct p_sign=Sign for Sin term, p_sign1=Sign for Cos term, xmm0 = r, xmm2 = %xmm6,%r2 =rr, r8=region
+	movapd	r(%rsp),%xmm0				#x
+	movapd	%xmm0,%xmm2					#move for x2
+	mulpd	%xmm2,%xmm2					#x2
+	movapd	rr(%rsp),%xmm6				#xx
+
+	mov	region(%rsp),%r8
+	mov 	.L__reald_one_zero(%rip),%r9		#compare value for cossin path
+	mov 	%r8,%r10
+	mov	%r8,%rax
+	and	.L__reald_one_one(%rip),%r8		#odd/even region for cos/sin
+
+	shr	$1,%r10						#~AB+A~B, A is sign and B is upper bit of region
+	mov	%r10,%rcx
+	not 	%r11						#ADDED TO CHANGE THE LOGIC
+	and	%r11,%r10
+	not	%rcx
+	not	%r11
+	and	%r11,%rcx
+	or	%rcx,%r10
+	and	.L__reald_one_one(%rip),%r10				#(~AB+A~B)&1
+
+	mov	%r10,%r11
+	and	%r9,%r11				#mask out the lower sign bit leaving the upper sign bit
+	shl	$63,%r10				#shift lower sign bit left by 63 bits
+	shl	$31,%r11				#shift upper sign bit left by 31 bits
+	mov 	 %r10,p_sign(%rsp)		#write out lower sign bit
+	mov 	 %r11,p_sign+8(%rsp)		#write out upper sign bit
+
+	add	.L__reald_one_one(%rip),%rax
+	and	.L__reald_two_two(%rip),%rax
+	shr	$1,%rax
+
+	mov	%rax,%rdx
+	and	%r9,%rdx				#mask out the lower sign bit leaving the upper sign bit
+	shl	$63,%rax				#shift lower sign bit left by 63 bits
+	shl	$31,%rdx				#shift upper sign bit left by 31 bits
+	mov 	 %rax,p_sign1(%rsp)		#write out lower sign bit
+	mov 	 %rdx,p_sign1+8(%rsp)		#write out upper sign bit
+
+
+	jmp .L__vrd2_sincos_approximate
+
+
+#ENDMAIN
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrd2_sincos_cleanup:
+
+	xorpd	p_sign(%rsp),%xmm5		# SIN sign
+	xorpd	p_sign1(%rsp),%xmm4		# COS sign
+
+	mov	p_sin(%rsp),%rdi
+	mov	p_cos(%rsp),%rsi
+
+	movapd	 %xmm5,(%rdi)			# save the sin
+	movapd	 %xmm4,(%rsi)			# save the cos
+
+.Lfinal_check:
+	add	$0x1C8,%rsp
+	ret
+
diff --git a/src/gas/vrd4cos.S b/src/gas/vrd4cos.S
new file mode 100644
index 0000000..5ecc97c
--- /dev/null
+++ b/src/gas/vrd4cos.S
@@ -0,0 +1,2987 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+# vrd4cos.s
+#
+# A vector implementation of the cos libm function.
+#
+# Prototype:
+#
+#    __m128d,__m128d __vrd4_cos(__m128d x1, __m128d x2);
+#
+# Computes Cosine of x for an array of input values.
+# Places the results into the supplied y array.
+# Does not perform error checking.
+# Denormal inputs may produce unexpected results.
+# This routine computes 4 double precision Cosine values at a time.
+# The four values are passed as packed doubles in xmm0 and xmm1.
+# The four results are returned as packed doubles in xmm0 and xmm1.
+# Note that this represents a non-standard ABI usage, as no ABI
+# ( and indeed C) currently allows returning 2 values for a function.
+# It is expected that some compilers may be able to take advantage of this
+# interface when implementing vectorized loops.  Using the array implementation
+# of the routine requires putting the inputs into memory, and retrieving
+# the results from memory.  This routine eliminates the need for this
+# overhead if the data does not already reside in memory.
+# This routine is derived directly from the array version.
+# Author: Harsha Jagasia
+# Email:  harsha.jagasia@amd.com
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+
+
+.data
+.align 16
+.L__real_7fffffffffffffff: 	.quad 0x07fffffffffffffff	#Sign bit zero
+				.quad 0x07fffffffffffffff
+.L__real_3ff0000000000000: 	.quad 0x03ff0000000000000	# 1.0
+				.quad 0x03ff0000000000000
+.L__real_v2p__27:		.quad 0x03e40000000000000	# 2p-27
+				.quad 0x03e40000000000000
+.L__real_3fe0000000000000: 	.quad 0x03fe0000000000000	# 0.5
+				.quad 0x03fe0000000000000
+.L__real_3fc5555555555555: 	.quad 0x03fc5555555555555	# 0.166666666666
+				.quad 0x03fc5555555555555
+.L__real_3fe45f306dc9c883: 	.quad 0x03fe45f306dc9c883	# twobypi
+				.quad 0x03fe45f306dc9c883
+.L__real_3ff921fb54400000: 	.quad 0x03ff921fb54400000	# piby2_1
+				.quad 0x03ff921fb54400000
+.L__real_3dd0b4611a626331: 	.quad 0x03dd0b4611a626331	# piby2_1tail
+				.quad 0x03dd0b4611a626331
+.L__real_3dd0b4611a600000: 	.quad 0x03dd0b4611a600000	# piby2_2
+				.quad 0x03dd0b4611a600000
+.L__real_3ba3198a2e037073: 	.quad 0x03ba3198a2e037073	# piby2_2tail
+				.quad 0x03ba3198a2e037073
+.L__real_fffffffff8000000: 	.quad 0x0fffffffff8000000	# mask for stripping head and tail
+				.quad 0x0fffffffff8000000
+.L__real_8000000000000000:	.quad 0x08000000000000000	# -0  or signbit
+				.quad 0x08000000000000000
+.L__reald_one_one:		.quad 0x00000000100000001	#
+				.quad 0
+.L__reald_two_two:		.quad 0x00000000200000002	#
+				.quad 0
+.L__reald_one_zero:		.quad 0x00000000100000000	# sin_cos_filter
+				.quad 0
+.L__reald_zero_one:		.quad 0x00000000000000001	#
+				.quad 0
+.L__reald_two_zero:		.quad 0x00000000200000000	#
+				.quad 0
+.L__realq_one_one:		.quad 0x00000000000000001	#
+				.quad 0x00000000000000001	#
+.L__realq_two_two:		.quad 0x00000000000000002	#
+				.quad 0x00000000000000002	#
+.L__real_1_x_mask:		.quad 0x0ffffffffffffffff	#
+				.quad 0x03ff0000000000000	#
+.L__real_zero:			.quad 0x00000000000000000	#
+				.quad 0x00000000000000000	#
+.L__real_one:			.quad 0x00000000000000001	#
+				.quad 0x00000000000000001	#
+
+.Lcosarray:
+	.quad	0x03fa5555555555555		# 0.0416667		   	c1
+	.quad	0x03fa5555555555555
+	.quad	0x0bf56c16c16c16967		# -0.00138889	   		c2
+	.quad	0x0bf56c16c16c16967
+	.quad	0x03efa01a019f4ec90		# 2.48016e-005			c3
+	.quad	0x03efa01a019f4ec90
+	.quad	0x0be927e4fa17f65f6		# -2.75573e-007			c4
+	.quad	0x0be927e4fa17f65f6
+	.quad	0x03e21eeb69037ab78		# 2.08761e-009			c5
+	.quad	0x03e21eeb69037ab78
+	.quad	0x0bda907db46cc5e42		# -1.13826e-011	   		c6
+	.quad	0x0bda907db46cc5e42
+.Lsinarray:
+	.quad	0x0bfc5555555555555		# -0.166667	   		s1
+	.quad	0x0bfc5555555555555
+	.quad	0x03f81111111110bb3		# 0.00833333	   		s2
+	.quad	0x03f81111111110bb3
+	.quad	0x0bf2a01a019e83e5c		# -0.000198413			s3
+	.quad	0x0bf2a01a019e83e5c
+	.quad	0x03ec71de3796cde01		# 2.75573e-006			s4
+	.quad	0x03ec71de3796cde01
+	.quad	0x0be5ae600b42fdfa7		# -2.50511e-008			s5
+	.quad	0x0be5ae600b42fdfa7
+	.quad	0x03de5e0b2f9a43bb8		# 1.59181e-010	   		s6
+	.quad	0x03de5e0b2f9a43bb8
+.Lsincosarray:
+	.quad	0x0bfc5555555555555		# -0.166667	   		s1
+	.quad	0x03fa5555555555555		# 0.0416667		   	c1
+	.quad	0x03f81111111110bb3		# 0.00833333	   		s2
+	.quad	0x0bf56c16c16c16967
+	.quad	0x0bf2a01a019e83e5c		# -0.000198413			s3
+	.quad	0x03efa01a019f4ec90
+	.quad	0x03ec71de3796cde01		# 2.75573e-006			s4
+	.quad	0x0be927e4fa17f65f6
+	.quad	0x0be5ae600b42fdfa7		# -2.50511e-008			s5
+	.quad	0x03e21eeb69037ab78
+	.quad	0x03de5e0b2f9a43bb8		# 1.59181e-010	   		s6
+	.quad	0x0bda907db46cc5e42
+.Lcossinarray:
+	.quad	0x03fa5555555555555		# 0.0416667		   	c1
+	.quad	0x0bfc5555555555555		# -0.166667	   		s1
+	.quad	0x0bf56c16c16c16967
+	.quad	0x03f81111111110bb3		# 0.00833333	   		s2
+	.quad	0x03efa01a019f4ec90
+	.quad	0x0bf2a01a019e83e5c		# -0.000198413			s3
+	.quad	0x0be927e4fa17f65f6
+	.quad	0x03ec71de3796cde01		# 2.75573e-006			s4
+	.quad	0x03e21eeb69037ab78
+	.quad	0x0be5ae600b42fdfa7		# -2.50511e-008			s5
+	.quad	0x0bda907db46cc5e42
+	.quad	0x03de5e0b2f9a43bb8		# 1.59181e-010	   		s6
+
+.align 16
+.Levencos_oddsin_tbl:
+		.quad	.Lcoscos_coscos_piby4		# 0		*
+		.quad	.Lcoscos_cossin_piby4		# 1		+
+		.quad	.Lcoscos_sincos_piby4		# 2
+		.quad	.Lcoscos_sinsin_piby4		# 3		+
+
+		.quad	.Lcossin_coscos_piby4		# 4
+		.quad	.Lcossin_cossin_piby4		# 5		*
+		.quad	.Lcossin_sincos_piby4		# 6
+		.quad	.Lcossin_sinsin_piby4		# 7
+
+		.quad	.Lsincos_coscos_piby4		# 8
+		.quad	.Lsincos_cossin_piby4		# 9
+		.quad	.Lsincos_sincos_piby4		# 10		*
+		.quad	.Lsincos_sinsin_piby4		# 11
+
+		.quad	.Lsinsin_coscos_piby4		# 12
+		.quad	.Lsinsin_cossin_piby4		# 13		+
+		.quad	.Lsinsin_sincos_piby4		# 14
+		.quad	.Lsinsin_sinsin_piby4		# 15		*
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    .text
+    .align 16
+    .p2align 4,,15
+
+# define local variable storage offsets
+.equ	p_temp,		0x00		# temporary for get/put bits operation
+.equ	p_temp1,	0x10		# temporary for get/put bits operation
+
+.equ	p_xmm6,		0x20		# temporary for get/put bits operation
+.equ	p_xmm7,		0x30		# temporary for get/put bits operation
+.equ	p_xmm8,		0x40		# temporary for get/put bits operation
+.equ	p_xmm9,		0x50		# temporary for get/put bits operation
+.equ	p_xmm10,	0x60		# temporary for get/put bits operation
+.equ	p_xmm11,	0x70		# temporary for get/put bits operation
+.equ	p_xmm12,	0x80		# temporary for get/put bits operation
+.equ	p_xmm13,	0x90		# temporary for get/put bits operation
+.equ	p_xmm14,	0x0A0		# temporary for get/put bits operation
+.equ	p_xmm15,	0x0B0		# temporary for get/put bits operation
+
+.equ	r,		0x0C0		# pointer to r for remainder_piby2
+.equ	rr,		0x0D0		# pointer to r for remainder_piby2
+.equ	region,		0x0E0		# pointer to r for remainder_piby2
+
+.equ	r1,		0x0F0		# pointer to r for remainder_piby2
+.equ	rr1,		0x0100		# pointer to r for remainder_piby2
+.equ	region1,	0x0110		# pointer to r for remainder_piby2
+
+.equ	p_temp2,	0x0120		# temporary for get/put bits operation
+.equ	p_temp3,	0x0130		# temporary for get/put bits operation
+
+.equ	p_temp4,	0x0140		# temporary for get/put bits operation
+.equ	p_temp5,	0x0150		# temporary for get/put bits operation
+
+.equ	p_original,	0x0160		# original x
+.equ	p_mask,		0x0170		# original x
+.equ	p_sign,		0x0180		# original x
+
+.equ	p_original1,	0x0190		# original x
+.equ	p_mask1,	0x01A0		# original x
+.equ	p_sign1,	0x01B0		# original x
+
+.globl __vrd4_cos
+    .type   __vrd4_cos,@function
+__vrd4_cos:
+	sub		$0x1C8,%rsp
+
+#DEBUG
+#	add		$0x1C8,%rsp
+#	ret
+#	movapd	%xmm0,%xmm4
+#	movapd	%xmm1,%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#STARTMAIN
+
+movapd	.L__real_7fffffffffffffff(%rip),%xmm2
+movdqa	%xmm0, p_original(%rsp)
+movdqa	%xmm1, p_original1(%rsp)
+
+andpd 	%xmm2,%xmm0				#Unsign
+andpd 	%xmm2,%xmm1				#Unsign
+
+movd	%xmm0,%rax				#rax is lower arg
+movhpd	%xmm0, p_temp+8(%rsp)			#
+mov    	p_temp+8(%rsp),%rcx			#rcx = upper arg
+movd	%xmm1,%r8				#rax is lower arg
+movhpd	%xmm1, p_temp1+8(%rsp)			#
+mov    	p_temp1+8(%rsp),%r9			#rcx = upper arg
+
+mov 	$0x3FE921FB54442D18,%rdx		#piby4	+
+mov	$0x411E848000000000,%r10		#5e5	+
+
+movapd	.L__real_3fe0000000000000(%rip),%xmm4	#0.5 for later use
+
+movapd	%xmm0,%xmm2				#x0
+movapd	%xmm1,%xmm3				#x1
+movapd	%xmm0,%xmm6				#x0
+movapd	%xmm1,%xmm7				#x1
+
+#DEBUG
+#	add		$0x1C8,%rsp
+#	ret
+#	movapd	%xmm0,%xmm4
+#	movapd	%xmm1,%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm2 = x, xmm4 =0.5/t, xmm6 =x
+# xmm3 = x, xmm5 =0.5/t, xmm7 =x
+.align 16
+.Leither_or_both_arg_gt_than_piby4:
+	cmp	%r10,%rax
+	jae	.Lfirst_or_next3_arg_gt_5e5
+
+	cmp	%r10,%rcx
+	jae	.Lsecond_or_next2_arg_gt_5e5
+
+	cmp	%r10,%r8
+	jae	.Lthird_or_fourth_arg_gt_5e5
+
+	cmp	%r10,%r9
+	jae	.Lfourth_arg_gt_5e5
+
+
+#      /* Find out what multiple of piby2 */
+#        npi2  = (int)(x * twobypi + 0.5);
+	movapd	.L__real_3fe45f306dc9c883(%rip),%xmm0
+	mulpd	%xmm0,%xmm2						# * twobypi
+	mulpd	%xmm0,%xmm3						# * twobypi
+
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	addpd	%xmm4,%xmm3						# +0.5, npi2
+
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm0		# piby2_1
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm1		# piby2_1
+
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	cvttpd2dq	%xmm3,%xmm5					# convert packed double to packed integers
+
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm9		# piby2_2
+
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+	cvtdq2pd	%xmm5,%xmm3					# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+
+	movd	%xmm4,%rax						# Region
+	movd	%xmm5,%rcx						# Region
+
+	mov	%rax,%r8
+	mov	%rcx,%r9
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm0						# npi2 * piby2_1;
+       mulpd	%xmm3,%xmm1						# npi2 * piby2_1;
+
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+       mulpd	%xmm3,%xmm9						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm0,%xmm6						# rhead  = x - npi2 * piby2_1;
+       subpd	%xmm1,%xmm7						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm0						# t
+       movapd	%xmm7,%xmm1						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm0						# rhead
+       subpd	%xmm9,%xmm1						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm3		# npi2 * piby2_2tail
+
+       subpd	%xmm0,%xmm6						# t-rhead
+       subpd	%xmm1,%xmm7						# t-rhead
+
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       subpd	%xmm7,%xmm9						# - ((t - rhead) - rtail)
+
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       addpd	%xmm3,%xmm9						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm4  = npi2 (int), xmm0 =rhead, xmm8 =rtail
+# xmm5  = npi2 (int), xmm1 =rhead, xmm9 =rtail
+
+#	paddd		.L__reald_one_one(%rip),%xmm4		; Sign
+#	paddd		.L__reald_one_one(%rip),%xmm5		; Sign
+#	pand		.L__reald_two_two(%rip),%xmm4
+#	pand		.L__reald_two_two(%rip),%xmm5
+#	punpckldq 	%xmm4,%xmm4
+#	punpckldq 	%xmm5,%xmm5
+#	psllq		$62,%xmm4
+#	psllq		$62,%xmm5
+
+
+	add .L__reald_one_one(%rip),%r8
+	add .L__reald_one_one(%rip),%r9
+	and .L__reald_two_two(%rip),%r8
+	and .L__reald_two_two(%rip),%r9
+
+	mov %r8,%r10
+	mov %r9,%r11
+	shl $62,%r8
+	and .L__reald_two_zero(%rip),%r10
+	shl $30,%r10
+	shl $62,%r9
+	and .L__reald_two_zero(%rip),%r11
+	shl $30,%r11
+
+	mov	 %r8,p_sign(%rsp)
+	mov	 %r10,p_sign+8(%rsp)
+	mov	 %r9,p_sign1(%rsp)
+	mov	 %r11,p_sign1+8(%rsp)
+
+# GET_BITS_DP64(rhead-rtail, uy);			   		; originally only rhead
+# xmm4  = Sign, xmm0 =rhead, xmm8 =rtail
+# xmm5  = Sign, xmm1 =rhead, xmm9 =rtail
+	movapd	%xmm0,%xmm6						# rhead
+	movapd	%xmm1,%xmm7						# rhead
+
+	and	.L__reald_one_one(%rip),%rax		# Region
+	and	.L__reald_one_one(%rip),%rcx		# Region
+
+	subpd	%xmm8,%xmm0						# r = rhead - rtail
+	subpd	%xmm9,%xmm1						# r = rhead - rtail
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm4  = Sign, xmm0 = r, xmm6 =rhead, xmm8 =rtail
+# xmm5  = Sign, xmm1 = r, xmm7 =rhead, xmm9 =rtail
+
+	subpd	%xmm0,%xmm6				#rr=rhead-r
+	subpd	%xmm1,%xmm7				#rr=rhead-r
+
+	mov	%rax,%r8
+	mov	%rcx,%r9
+
+	movapd	%xmm0,%xmm2
+	movapd	%xmm1,%xmm3
+
+	mulpd	%xmm0,%xmm2				# r2
+	mulpd	%xmm1,%xmm3				# r2
+
+	subpd	%xmm8,%xmm6				#rr=(rhead-r) -rtail
+	subpd	%xmm9,%xmm7				#rr=(rhead-r) -rtail
+
+
+	and	.L__reald_zero_one(%rip),%rax
+	and	.L__reald_zero_one(%rip),%rcx
+	shr	$31,%r8
+	shr	$31,%r9
+	or	%r8,%rax
+	or	%r9,%rcx
+	shl	$2,%rcx
+	or	%rcx,%rax
+
+	leaq	 .Levencos_oddsin_tbl(%rip),%rsi
+	jmp	 *(%rsi,%rax,8)				#Jmp table for cos/sin calculation based on even/odd region
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lfirst_or_next3_arg_gt_5e5:
+# %rcx,,%rax r8, r9
+
+#DEBUG
+#	movapd	%xmm0,%xmm4
+#	movapd	%xmm1,%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+	cmp	%r10,%rcx				#is upper arg >= 5e5
+	jae	.Lboth_arg_gt_5e5
+
+.Llower_arg_gt_5e5:
+# Upper Arg is < 5e5, Lower arg is >= 5e5
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+# Be sure not to use %xmm3,%xmm1 and xmm7
+# Use %xmm8,,%xmm5 xmm10, xmm12
+#	    %xmm11,,%xmm9 xmm13
+
+
+#DEBUG
+#	movapd	%xmm0,%xmm4
+#	movapd	%xmm1,%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+
+	movlpd	 %xmm0,r(%rsp)		#Save lower fp arg for remainder_piby2 call
+	movhlps	%xmm0,%xmm0			#Needed since we want to work on upper arg
+	movhlps	%xmm2,%xmm2
+	movhlps	%xmm6,%xmm6
+
+# Work on Upper arg
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm4,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm8		# xmm8 = piby2_1
+	cvttsd2si	%xmm2,%ecx				# ecx = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm10		# xmm10 = piby2_2
+	cvtsi2sd	%ecx,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm8					# npi2 * piby2_1
+	subsd	%xmm8,%xmm6					# xmm6 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm12		# xmm12 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm6,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm10					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm10,%xmm6					# xmm6 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm12     					# npi2 * piby2_2tail
+       subsd	%xmm6,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm10					# (rtail-(t-rhead))
+       addsd	%xmm12,%xmm10					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %ecx,region+4(%rsp)			# store upper region
+       movsd	 %xmm6,%xmm0
+       subsd	 %xmm10,%xmm0					# xmm0 = r=(rhead-rtail)
+       subsd	 %xmm0,%xmm6					# rr=rhead-r
+       subsd	 %xmm10,%xmm6					# xmm6 = rr=((rhead-r) -rtail)
+       movlpd	 %xmm0,r+8(%rsp)			# store upper r
+       movlpd	 %xmm6,rr+8(%rsp)			# store upper rr
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#Note that volatiles will be trashed by the call
+#We will construct r, rr, region and sign
+
+# Work on Lower arg
+	mov		$0x07ff0000000000000,%r11			# is lower arg nan/inf
+	mov		%r11,%r10
+	and		%rax,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_cos_lower_naninf
+
+
+	mov	  %r8,p_temp(%rsp)
+	mov	  %r9,p_temp2(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region(%rsp),%rdx			# lower arg is **NOT** nan/inf
+	lea	 rr(%rsp),%rsi
+	lea	 r(%rsp),%rdi
+	movlpd	 r(%rsp),%xmm0	#Restore lower fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+
+	mov	 p_temp(%rsp),%r8
+	mov	 p_temp2(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+	jmp 	0f
+
+.L__vrd4_cos_lower_naninf:
+	mov	p_original(%rsp),%rax			# upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rax
+	mov	 %rax,r(%rsp)				# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr(%rsp)				# rr = 0
+	mov	 %r10d,region(%rsp)			# region =0
+
+.align 16
+0:
+
+
+#DEBUG
+#	movapd	.LOWORD,%xmm4 PTR r[rsp]
+#	movapd	%xmm1,%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+
+
+	jmp 	.Lcheck_next2_args
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lboth_arg_gt_5e5:
+#Upper Arg is >= 5e5, Lower arg is >= 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+
+
+#DEBUG
+#	movapd	%xmm0,%xmm4
+#	movapd	%xmm1,%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+
+
+
+	movhpd 	%xmm0,r+8(%rsp)		#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r11			#is lower arg nan/inf
+	mov		%r11,%r10
+	and		%rax,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_cos_lower_naninf_of_both_gt_5e5
+
+	mov	  %rcx,p_temp(%rsp)			#Save upper arg
+	mov	  %r8,p_temp2(%rsp)
+	mov	  %r9,p_temp4(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	 rr(%rsp),%rsi
+	lea	 r(%rsp),%rdi
+        call    __amd_remainder_piby2@PLT
+
+	mov	 p_temp(%rsp),%rcx			#Restore upper arg
+	mov	 p_temp2(%rsp),%r8
+	mov	 p_temp4(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+
+	jmp 	0f
+
+.L__vrd4_cos_lower_naninf_of_both_gt_5e5:				#lower arg is nan/inf
+	mov	p_original(%rsp),%rax
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rax
+	mov	 %rax,r(%rsp)				#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr(%rsp)				#rr = 0
+	mov	 %r10d,region(%rsp)			#region = 0
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r11			#is upper arg nan/inf
+	mov		%r11,%r10
+	and		%rcx,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_cos_upper_naninf_of_both_gt_5e5
+
+
+	mov	  %r8,p_temp(%rsp)
+	mov	  %r9,p_temp2(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region+4(%rsp),%rdx			#upper arg is **NOT** nan/inf
+	lea	 rr+8(%rsp),%rsi
+	lea	 r+8(%rsp),%rdi
+	movlpd	 r+8(%rsp),%xmm0			#Restore upper fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+
+	mov	 p_temp(%rsp),%r8
+	mov	 p_temp2(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+
+	jmp 	0f
+
+.L__vrd4_cos_upper_naninf_of_both_gt_5e5:
+	mov	p_original+8(%rsp),%rcx		#upper arg is nan/inf
+#	movd	%xmm6,%rcx					;upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rcx
+	mov	%rcx,r+8(%rsp)				#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	%r10,rr+8(%rsp)			#rr = 0
+	mov	%r10d,region+4(%rsp)			#region = 0
+
+.align 16
+0:
+	jmp 	.Lcheck_next2_args
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lsecond_or_next2_arg_gt_5e5:
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+# Do not use %xmm3,,%xmm1 xmm7
+# Restore xmm4 and %xmm3,,%xmm1 xmm7
+# Can use %xmm10,,%xmm8 xmm12
+#   %xmm9,,%xmm5 xmm11, xmm13
+
+	movhpd	%xmm0,r+8(%rsp)	#Save upper fp arg for remainder_piby2 call
+#	movlhps	%xmm0,%xmm0			;Not needed since we want to work on lower arg, but done just to be safe and avoide exceptions due to nan/inf and to mirror the lower_arg_gt_5e5 case
+#	movlhps	%xmm2,%xmm2
+#	movlhps	%xmm6,%xmm6
+
+# Work on Lower arg
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm4,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm8		# xmm3 = piby2_1
+	cvttsd2si	%xmm2,%eax				# ecx = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm10		# xmm1 = piby2_2
+	cvtsi2sd	%eax,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm8					# npi2 * piby2_1
+	subsd	%xmm8,%xmm6					# xmm6 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm12		# xmm7 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm6,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm10					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm10,%xmm6					# xmm6 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm12     					# npi2 * piby2_2tail
+       subsd	%xmm6,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm10					# (rtail-(t-rhead))
+       addsd	%xmm12,%xmm10					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %eax,region(%rsp)			# store upper region
+       movsd	%xmm6,%xmm0
+       subsd	%xmm10,%xmm0					# xmm0 = r=(rhead-rtail)
+       subsd	%xmm0,%xmm6					# rr=rhead-r
+       subsd	%xmm10,%xmm6					# xmm6 = rr=((rhead-r) -rtail)
+       movlpd	 %xmm0,r(%rsp)				# store upper r
+       movlpd	 %xmm6,rr(%rsp)				# store upper rr
+
+#Work on Upper arg
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+	mov		$0x07ff0000000000000,%r11			# is upper arg nan/inf
+	mov		%r11,%r10
+	and		%rcx,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_cos_upper_naninf
+
+
+	mov	  %r8,p_temp(%rsp)
+	mov	  %r9,p_temp2(%rsp)
+	movapd	 %xmm1,p_temp1(%rsp)
+	movapd	 %xmm3,p_temp3(%rsp)
+	movapd	 %xmm7,p_temp5(%rsp)
+
+	lea	 region+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 rr+8(%rsp),%rsi
+	lea	 r+8(%rsp),%rdi
+	movlpd	 r+8(%rsp),%xmm0	#Restore upper fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+
+	mov	 p_temp(%rsp),%r8
+	mov	 p_temp2(%rsp),%r9
+	movapd	p_temp1(%rsp),%xmm1
+	movapd	p_temp3(%rsp),%xmm3
+	movapd	p_temp5(%rsp),%xmm7
+	jmp 	0f
+
+.L__vrd4_cos_upper_naninf:
+	mov	p_original+8(%rsp),%rcx		# upper arg is nan/inf
+#	mov	r+8(%rsp),%rcx				; upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rcx
+	mov	 %rcx,r+8(%rsp)				# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr+8(%rsp)			# rr = 0
+	mov	 %r10d,region+4(%rsp)			# region =0
+
+.align 16
+0:
+	jmp 	.Lcheck_next2_args
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcheck_next2_args:
+
+#DEBUG
+#	movapd	r(%rsp),%xmm4
+#	movapd	%xmm1,%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+	mov	$0x411E848000000000,%r10			#5e5	+
+
+	cmp	%r10,%r8
+	jae	.Lfirst_second_done_third_or_fourth_arg_gt_5e5
+
+	cmp	%r10,%r9
+	jae	.Lfirst_second_done_fourth_arg_gt_5e5
+
+# Work on next two args, both < 5e5
+# %xmm3,,%xmm1 xmm5 = x, xmm4 = 0.5
+
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4			#Restore 0.5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm3						# * twobypi
+	addpd	%xmm4,%xmm3						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm1		# piby2_1
+	cvttpd2dq	%xmm3,%xmm5					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm9		# piby2_2
+	cvtdq2pd	%xmm5,%xmm3					# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movq	 %xmm5,region1(%rsp)						# Region
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm3,%xmm1						# npi2 * piby2_1;
+
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm3,%xmm9						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm1,%xmm7						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm7,%xmm1						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm9,%xmm1						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm3		# npi2 * piby2_2tail
+
+       subpd	%xmm1,%xmm7						# t-rhead
+       subpd	%xmm7,%xmm9						# - ((t - rhead) - rtail)
+       addpd	%xmm3,%xmm9						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+       movapd	%xmm1,%xmm7						# rhead
+       subpd	%xmm9,%xmm1						# r = rhead - rtail
+       movapd	 %xmm1,r1(%rsp)
+
+       subpd	%xmm1,%xmm7						# rr=rhead-r
+       subpd	%xmm9,%xmm7						# rr=(rhead-r) -rtail
+       movapd	 %xmm7,rr1(%rsp)
+
+	jmp	.L__vrd4_cos_reconstruct
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lthird_or_fourth_arg_gt_5e5:
+#first two args are < 5e5, third arg >= 5e5, fourth arg >= 5e5 or < 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+# Do not use %xmm3,,%xmm1 xmm7
+# Can use 	%xmm11,,%xmm9 xmm13
+# 	%xmm8,,%xmm5 xmm10, xmm12
+# Restore xmm4
+
+# Work on first two args, both < 5e5
+
+#DEBUG
+#	movapd	%xmm0,%xmm4
+#	movapd	%xmm1,%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm2						# * twobypi
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm0		# piby2_1
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movq	 %xmm4,region(%rsp)						# Region
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm0						# npi2 * piby2_1;
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm0,%xmm6						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm0						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm0						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+
+       subpd	%xmm0,%xmm6						# t-rhead
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+       movapd	%xmm0,%xmm6						# rhead
+       subpd	%xmm8,%xmm0						# r = rhead - rtail
+       movapd	 %xmm0,r(%rsp)
+
+       subpd	%xmm0,%xmm6						# rr=rhead-r
+       subpd	%xmm8,%xmm6						# rr=(rhead-r) -rtail
+       movapd	 %xmm6,rr(%rsp)
+
+
+# Work on next two args, third arg >= 5e5, fourth arg >= 5e5 or < 5e5
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lfirst_second_done_third_or_fourth_arg_gt_5e5:
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+
+
+#DEBUG
+#	movapd	r(%rsp),%xmm4
+#	movapd	%xmm1,%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+	mov	$0x411E848000000000,%r10			#5e5	+
+	cmp	%r10,%r9
+	jae	.Lboth_arg_gt_5e5_higher
+
+
+# Upper Arg is <5e5, Lower arg is >= 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+	movlpd	 %xmm1,r1(%rsp)		#Save lower fp arg for remainder_piby2 call
+	movhlps	%xmm1,%xmm1			#Needed since we want to work on upper arg
+	movhlps	%xmm3,%xmm3
+	movhlps	%xmm7,%xmm7
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4	#0.5 for later use
+
+# Work on Upper arg
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm3		# x*twobypi
+	addsd	%xmm4,%xmm3					# xmm3 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm2		# xmm2 = piby2_1
+	cvttsd2si	%xmm3,%r9d				# r9d = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm0		# xmm0 = piby2_2
+	cvtsi2sd	%r9d,%xmm3				# xmm3 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm3,%xmm2					# npi2 * piby2_1
+	subsd	%xmm2,%xmm7					# xmm7 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm7,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm3,%xmm0					# xmm0 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm0,%xmm7					# xmm7 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm3,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm7,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm0					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm0					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %r9d,region1+4(%rsp)			# store upper region
+       movsd	%xmm7,%xmm1
+       subsd	%xmm0,%xmm1					# xmm1 = r=(rhead-rtail)
+       subsd	%xmm1,%xmm7					# rr=rhead-r
+       subsd	%xmm0,%xmm7					# xmm7 = rr=((rhead-r) -rtail)
+       movlpd	 %xmm1,r1+8(%rsp)			# store upper r
+       movlpd	 %xmm7,rr1+8(%rsp)			# store upper rr
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+
+# Work on Lower arg
+	mov		$0x07ff0000000000000,%r11			# is lower arg nan/inf
+	mov		%r11,%r10
+	and		%r8,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_cos_lower_naninf_higher
+
+	lea	 region1(%rsp),%rdx			# lower arg is **NOT** nan/inf
+	lea	 rr1(%rsp),%rsi
+	lea	 r1(%rsp),%rdi
+	movlpd	 r1(%rsp),%xmm0				#Restore lower fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+	jmp 	0f
+
+.L__vrd4_cos_lower_naninf_higher:
+	mov	p_original1(%rsp),%r8			# upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r8
+	mov	 %r8,r1(%rsp)				# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr1(%rsp)				# rr = 0
+	mov	 %r10d,region1(%rsp)			# region =0
+
+.align 16
+0:
+
+
+#DEBUG
+#	movapd	rr(%rsp),%xmm4
+#	movapd	rr1(%rsp),%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+	jmp 	.L__vrd4_cos_reconstruct
+
+
+
+
+
+
+
+.align 16
+.Lboth_arg_gt_5e5_higher:
+# Upper Arg is >= 5e5, Lower arg is >= 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+
+#DEBUG
+#	movapd	r(%rsp),%xmm4
+#	movd	%r8,%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+	movhpd 	%xmm1,r1+8(%rsp)				#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r11			#is lower arg nan/inf
+	mov		%r11,%r10
+	and		%r8,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_cos_lower_naninf_of_both_gt_5e5_higher
+
+	mov	  %r9,p_temp1(%rsp)			#Save upper arg
+	lea	 region1(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	 rr1(%rsp),%rsi
+	lea	 r1(%rsp),%rdi
+	movsd	 %xmm1,%xmm0
+        call    __amd_remainder_piby2@PLT
+	mov	 p_temp1(%rsp),%r9			#Restore upper arg
+
+
+#DEBUG
+#	movapd	 r(%rsp),%xmm4
+#	mov	 QWORD PTR r1[rsp+8], r9
+#	movapd	 r1(%rsp),%xmm5
+#	xorpd	 %xmm0,%xmm0
+#	xorpd	 %xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+
+
+	jmp 	0f
+
+.L__vrd4_cos_lower_naninf_of_both_gt_5e5_higher:				#lower arg is nan/inf
+	mov	p_original1(%rsp),%r8
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r8
+	mov	 %r8,r1(%rsp)				#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr1(%rsp)				#rr = 0
+	mov	 %r10d,region1(%rsp)			#region = 0
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r11			#is upper arg nan/inf
+	mov		%r11,%r10
+	and		%r9,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_cos_upper_naninf_of_both_gt_5e5_higher
+
+	lea	 region1+4(%rsp),%rdx			#upper arg is **NOT** nan/inf
+	lea	 rr1+8(%rsp),%rsi
+	lea	 r1+8(%rsp),%rdi
+	movlpd	 r1+8(%rsp),%xmm0			#Restore upper fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+	jmp 	0f
+
+.L__vrd4_cos_upper_naninf_of_both_gt_5e5_higher:
+	mov	p_original1+8(%rsp),%r9		#upper arg is nan/inf
+#	movd	%xmm6,%r9					;upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r9
+	mov	 %r9,r1+8(%rsp)				#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr1+8(%rsp)			#rr = 0
+	mov	 %r10d,region1+4(%rsp)			#region = 0
+
+.align 16
+0:
+
+#DEBUG
+#	movapd	r(%rsp),%xmm4
+#	movapd	r1(%rsp),%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+
+	jmp 	.L__vrd4_cos_reconstruct
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lfourth_arg_gt_5e5:
+#first two args are < 5e5, third arg < 5e5, fourth arg >= 5e5
+#%rcx,,%rax r8, r9
+#%xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+
+# Work on first two args, both < 5e5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm2						# * twobypi
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm0		# piby2_1
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movq	 %xmm4,region(%rsp)						# Region
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm0						# npi2 * piby2_1;
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm0,%xmm6						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm0						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm0						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+
+       subpd	%xmm0,%xmm6						# t-rhead
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+       movapd	%xmm0,%xmm6						# rhead
+       subpd	%xmm8,%xmm0						# r = rhead - rtail
+       movapd	 %xmm0,r(%rsp)
+
+       subpd	%xmm0,%xmm6						# rr=rhead-r
+       subpd	%xmm8,%xmm6						# rr=(rhead-r) -rtail
+       movapd	 %xmm6,rr(%rsp)
+
+
+# Work on next two args, third arg < 5e5, fourth arg >= 5e5
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lfirst_second_done_fourth_arg_gt_5e5:
+
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+	movhpd	 %xmm1,r1+8(%rsp)	#Save upper fp arg for remainder_piby2 call
+#	movlhps	%xmm1,%xmm1			;Not needed since we want to work on lower arg, but done just to be safe and avoide exceptions due to nan/inf and to mirror the lower_arg_gt_5e5 case
+#	movlhps	%xmm3,%xmm3
+#	movlhps	%xmm7,%xmm7
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4	#0.5 for later use
+
+# Work on Lower arg
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm3		# x*twobypi
+	addsd	%xmm4,%xmm3					# xmm3 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm2		# xmm2 = piby2_1
+	cvttsd2si	%xmm3,%r8d				# r8d = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm0		# xmm0 = piby2_2
+	cvtsi2sd	%r8d,%xmm3				# xmm3 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm3,%xmm2					# npi2 * piby2_1
+	subsd	%xmm2,%xmm7					# xmm7 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm7,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm3,%xmm0					# xmm0 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm0,%xmm7					# xmm7 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm3,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm7,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm0					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm0					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %r8d,region1(%rsp)			# store lower region
+       movsd	%xmm7,%xmm1
+       subsd	%xmm0,%xmm1					# xmm0 = r=(rhead-rtail)
+       subsd	%xmm1,%xmm7					# rr=rhead-r
+       subsd	%xmm0,%xmm7					# xmm6 = rr=((rhead-r) -rtail)
+
+       movlpd	 %xmm1,r1(%rsp)				# store upper r
+       movlpd	 %xmm7,rr1(%rsp)				# store upper rr
+
+#Work on Upper arg
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+	mov		$0x07ff0000000000000,%r11			# is upper arg nan/inf
+	mov		%r11,%r10
+	and		%r9,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_cos_upper_naninf_higher
+
+	lea	 region1+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 rr1+8(%rsp),%rsi
+	lea	 r1+8(%rsp),%rdi
+	movlpd	 r1+8(%rsp),%xmm0	#Restore upper fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+	jmp 	0f
+
+.L__vrd4_cos_upper_naninf_higher:
+	mov	p_original1+8(%rsp),%r9		# upper arg is nan/inf
+#	mov	r1+8(%rsp),%r9			# upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r9
+	mov	 %r9,r1+8(%rsp)			# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr1+8(%rsp)		# rr = 0
+	mov	 %r10d,region1+4(%rsp)		# region =0
+
+.align 16
+0:
+	jmp	.L__vrd4_cos_reconstruct
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrd4_cos_reconstruct:
+#Results
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+#DEBUG
+#	movapd	region(%rsp),%xmm4
+#	movapd	region1(%rsp),%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+	movapd	r(%rsp),%xmm0
+	movapd	r1(%rsp),%xmm1
+
+	movapd	rr(%rsp),%xmm6
+	movapd	rr1(%rsp),%xmm7
+
+	mov	region(%rsp),%rax
+	mov	region1(%rsp),%rcx
+
+	mov	%rax,%r8
+	mov	%rcx,%r9
+
+	add .L__reald_one_one(%rip),%r8
+	add .L__reald_one_one(%rip),%r9
+	and .L__reald_two_two(%rip),%r8
+	and .L__reald_two_two(%rip),%r9
+
+	mov %r8,%r10
+	mov %r9,%r11
+	shl $62,%r8
+	and .L__reald_two_zero(%rip),%r10
+	shl $30,%r10
+	shl $62,%r9
+	and .L__reald_two_zero(%rip),%r11
+	shl $30,%r11
+
+	mov	 %r8,p_sign(%rsp)
+	mov	 %r10,p_sign+8(%rsp)
+	mov	 %r9,p_sign1(%rsp)
+	mov	 %r11,p_sign1+8(%rsp)
+
+	and	.L__reald_one_one(%rip),%rax		# Region
+	and	.L__reald_one_one(%rip),%rcx		# Region
+
+	mov	%rax,%r8
+	mov	%rcx,%r9
+
+	movapd	%xmm0,%xmm2
+	movapd	%xmm1,%xmm3
+
+	mulpd	%xmm0,%xmm2				# r2
+	mulpd	%xmm1,%xmm3				# r2
+
+	and	.L__reald_zero_one(%rip),%rax
+	and	.L__reald_zero_one(%rip),%rcx
+	shr	$31,%r8
+	shr	$31,%r9
+	or	%r8,%rax
+	or	%r9,%rcx
+	shl	$2,%rcx
+	or	%rcx,%rax
+
+
+
+#DEBUG
+#	movd	%rax,%xmm4
+#	movd	%rax,%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+	leaq	 .Levencos_oddsin_tbl(%rip),%rsi
+	jmp	 *(%rsi,%rax,8)	#Jmp table for cos/sin calculation based on even/odd region
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrd4_cos_cleanup:
+
+	movapd	  p_sign(%rsp),%xmm0
+	movapd	  p_sign1(%rsp),%xmm1
+
+	xorpd	%xmm4,%xmm0			# (+) Sign
+	xorpd	%xmm5,%xmm1			# (+) Sign
+
+	add	$0x1C8,%rsp
+	ret
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;JUMP TABLE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcoscos_coscos_piby4:
+	movapd	%xmm2,%xmm10					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lcosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lcosarray+0x50(%rip),%xmm5			# c6
+
+	movapd	.Lcosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lcosarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	 %xmm2,%xmm4					# c6*x2
+	mulpd	 %xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# r
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+
+	mulpd	 %xmm2,%xmm8					# c3*x2
+	mulpd	 %xmm3,%xmm9					# c3*x2
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm10		# -t=r-1.0	;trash r
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11		# -t=r-1.0	;trash r
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lcosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lcosarray+0x40(%rip),%xmm5			# c5+x2c6
+
+	addpd	.Lcosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lcosarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm10		# 1 + (-t)	;trash t
+	addpd   .L__real_3ff0000000000000(%rip),%xmm11		# 1 + (-t)	;trash t
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lcosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+
+	addpd	.Lcosarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lcosarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm2,%xmm2					# x4 recalculate
+	mulpd	%xmm3,%xmm3					# x4 recalculate
+
+	movapd   p_temp2(%rsp),%xmm12			# r
+	movapd   p_temp3(%rsp),%xmm13			# r
+
+	mulpd	%xmm0,%xmm6					# x * xx
+	mulpd	%xmm1,%xmm7					# x * xx
+
+	subpd   %xmm12,%xmm10					# (1 + (-t)) - r
+	subpd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x4 * zc
+
+	subpd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx
+	subpd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	addpd   %xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addpd   %xmm11,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm12		# t relaculate, -t = r-1
+	subpd	.L__real_3ff0000000000000(%rip),%xmm13		# t relaculate, -t = r-1
+
+	subpd   %xmm12,%xmm4					# + t
+	subpd   %xmm13,%xmm5					# + t
+
+	jmp 	.L__vrd4_cos_cleanup
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcossin_cossin_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	movapd	 %xmm6,p_temp(%rsp)		# Store rr
+	movapd	 %xmm7,p_temp1(%rsp)		# Store rr
+
+	movdqa	.Lsincosarray+0x50(%rip),%xmm4		# s6
+	movdqa	.Lsincosarray+0x50(%rip),%xmm5		# s6
+	movapd	.Lsincosarray+0x20(%rip),%xmm8		# s3
+	movapd	.Lsincosarray+0x20(%rip),%xmm9		# s3
+
+	movapd	%xmm2,%xmm10				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+
+	mulpd	%xmm2,%xmm4				# x2s6
+	mulpd	%xmm3,%xmm5				# x2s6
+	mulpd	%xmm2,%xmm8				# x2s3
+	mulpd	%xmm3,%xmm9				# x2s3
+
+	mulpd	%xmm2,%xmm10				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lsincosarray+0x40(%rip),%xmm4		# s5+x2s6
+	addpd	.Lsincosarray+0x40(%rip),%xmm5		# s5+x2s6
+	addpd	.Lsincosarray+0x10(%rip),%xmm8		# s2+x2s3
+	addpd	.Lsincosarray+0x10(%rip),%xmm9		# s2+x2s3
+
+	movapd	%xmm2,%xmm12				# move x2 for x6
+	movapd	%xmm3,%xmm13				# move x2 for x6
+
+	mulpd	%xmm2,%xmm4				# x2(s5+x2s6)
+	mulpd	%xmm3,%xmm5				# x2(s5+x2s6)
+	mulpd	%xmm2,%xmm8				# x2(s2+x2s3)
+	mulpd	%xmm3,%xmm9				# x2(s2+x2s3)
+
+	mulpd	%xmm10,%xmm12				# x6
+	mulpd	%xmm11,%xmm13				# x6
+
+	addpd	.Lsincosarray+0x30(%rip),%xmm4		# s4+x2(s5+x2s6)
+	addpd	.Lsincosarray+0x30(%rip),%xmm5		# s4+x2(s5+x2s6)
+	addpd	.Lsincosarray(%rip),%xmm8		# s1+x2(s2+x2s3)
+	addpd	.Lsincosarray(%rip),%xmm9		# s1+x2(s2+x2s3)
+
+	movhlps	%xmm10,%xmm10				# move high x4 for cos term
+	movhlps	%xmm11,%xmm11				# move high x4 for cos term
+	mulpd	%xmm12,%xmm4				# x6(s4+x2(s5+x2s6))
+	mulpd	%xmm13,%xmm5				# x6(s4+x2(s5+x2s6))
+
+	movsd	%xmm2,%xmm6				# move low x2 for x3 for sin term
+	movsd	%xmm3,%xmm7				# move low x2 for x3 for sin term
+	mulsd	%xmm0,%xmm6				# get low x3 for sin term
+	mulsd	%xmm1,%xmm7				# get low x3 for sin term
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for sin and cos terms
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for sin and cos terms
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm2,%xmm12				# move high r for cos
+	movhlps	%xmm3,%xmm13				# move high r for cos
+	movhlps	%xmm4,%xmm8				# xmm4 = sin , xmm8 = cos
+	movhlps	%xmm5,%xmm9				# xmm4 = sin , xmm8 = cos
+
+	mulsd	%xmm6,%xmm4				# sin *x3
+	mulsd	%xmm7,%xmm5				# sin *x3
+	mulsd	%xmm10,%xmm8				# cos *x4
+	mulsd	%xmm11,%xmm9				# cos *x4
+
+	mulsd	p_temp(%rsp),%xmm2		# 0.5 * x2 * xx for sin term
+	mulsd	p_temp1(%rsp),%xmm3		# 0.5 * x2 * xx for sin term
+	movsd	%xmm12,%xmm6				# Keep high r for cos term
+	movsd	%xmm13,%xmm7				# Keep high r for cos term
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12 	# -t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13 	# -t=r-1.0
+
+	subsd	%xmm2,%xmm4				# sin - 0.5 * x2 *xx
+	subsd	%xmm3,%xmm5				# sin - 0.5 * x2 *xx
+
+	movhlps	%xmm0,%xmm10				# move high x for x*xx for cos term
+	movhlps	%xmm1,%xmm11				# move high x for x*xx for cos term
+
+	mulsd	p_temp+8(%rsp),%xmm10		# x * xx
+	mulsd	p_temp1+8(%rsp),%xmm11		# x * xx
+
+	movsd	%xmm12,%xmm2				# move -t for cos term
+	movsd	%xmm13,%xmm3				# move -t for cos term
+
+	addsd	.L__real_3ff0000000000000(%rip),%xmm12 	# 1+(-t)
+	addsd	.L__real_3ff0000000000000(%rip),%xmm13	# 1+(-t)
+	addsd	p_temp(%rsp),%xmm4			# sin+xx
+	addsd	p_temp1(%rsp),%xmm5			# sin+xx
+	subsd	%xmm6,%xmm12				# (1-t) - r
+	subsd	%xmm7,%xmm13				# (1-t) - r
+	subsd	%xmm10,%xmm12				# ((1 + (-t)) - r) - x*xx
+	subsd	%xmm11,%xmm13				# ((1 + (-t)) - r) - x*xx
+	addsd	%xmm0,%xmm4				# sin + x
+	addsd	%xmm1,%xmm5				# sin + x
+	addsd   %xmm12,%xmm8				# cos+((1-t)-r - x*xx)
+	addsd   %xmm13,%xmm9				# cos+((1-t)-r - x*xx)
+	subsd   %xmm2,%xmm8				# cos+t
+	subsd   %xmm3,%xmm9				# cos+t
+
+	movlhps	%xmm8,%xmm4
+	movlhps	%xmm9,%xmm5
+	jmp 	.L__vrd4_cos_cleanup
+
+.align 16
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lsincos_cossin_piby4:					# changed from sincos_sincos
+							# xmm1 is cossin and xmm0 is sincos
+
+	movapd	 %xmm6,p_temp(%rsp)		# Store rr
+	movapd	 %xmm7,p_temp1(%rsp)		# Store rr
+	movapd	 %xmm1,p_temp3(%rsp)		# Store r for the sincos term
+
+	movapd	.Lsincosarray+0x50(%rip),%xmm4		# s6
+	movapd	.Lcossinarray+0x50(%rip),%xmm5		# s6
+	movdqa	.Lsincosarray+0x20(%rip),%xmm8		# s3
+	movdqa	.Lcossinarray+0x20(%rip),%xmm9		# s3
+
+	movapd	%xmm2,%xmm10				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+
+	mulpd	%xmm2,%xmm4				# x2s6
+	mulpd	%xmm3,%xmm5				# x2s6
+	mulpd	%xmm2,%xmm8				# x2s3
+	mulpd	%xmm3,%xmm9				# x2s3
+
+	mulpd	%xmm2,%xmm10				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lsincosarray+0x40(%rip),%xmm4		# s5+x2s6
+	addpd	.Lcossinarray+0x40(%rip),%xmm5		# s5+x2s6
+	addpd	.Lsincosarray+0x10(%rip),%xmm8		# s2+x2s3
+	addpd	.Lcossinarray+0x10(%rip),%xmm9		# s2+x2s3
+
+	movapd	%xmm2,%xmm12				# move x2 for x6
+	movapd	%xmm3,%xmm13				# move x2 for x6
+
+	mulpd	%xmm2,%xmm4				# x2(s5+x2s6)
+	mulpd	%xmm3,%xmm5				# x2(s5+x2s6)
+	mulpd	%xmm2,%xmm8				# x2(s2+x2s3)
+	mulpd	%xmm3,%xmm9				# x2(s2+x2s3)
+
+	mulpd	%xmm10,%xmm12				# x6
+	mulpd	%xmm11,%xmm13				# x6
+
+	addpd	.Lsincosarray+0x30(%rip),%xmm4		# s4+x2(s5+x2s6)
+	addpd	.Lcossinarray+0x30(%rip),%xmm5		# s4+x2(s5+x2s6)
+	addpd	.Lsincosarray(%rip),%xmm8		# s1+x2(s2+x2s3)
+	addpd	.Lcossinarray(%rip),%xmm9		# s1+x2(s2+x2s3)
+
+	movhlps	%xmm10,%xmm10				# move high x4 for cos term
+
+	mulpd	%xmm12,%xmm4				# x6(s4+x2(s5+x2s6))
+	mulpd	%xmm13,%xmm5				# x6(s4+x2(s5+x2s6))
+
+	movsd	%xmm2,%xmm6				# move low x2 for x3 for sin term  (cossin)
+	movhlps	%xmm3,%xmm7				# move high x2 for x3 for sin term (sincos)
+
+	mulsd	%xmm0,%xmm6				# get low x3 for sin term
+	mulsd	p_temp3+8(%rsp),%xmm7		# get high x3 for sin term
+
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for sin and cos terms
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for sin and cos terms
+
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm2,%xmm12				# move high r for cos (cossin)
+	movhlps	%xmm3,%xmm13				# move high 0.5*x2 for sin term (sincos)
+
+	movhlps	%xmm4,%xmm8				# xmm8 = cos , xmm4 = sin	(cossin)
+	movhlps	%xmm5,%xmm9				# xmm9 = sin , xmm5 = cos	(sincos)
+
+	mulsd	%xmm6,%xmm4				# sin *x3
+	mulsd	%xmm11,%xmm5				# cos *x4
+	mulsd	%xmm10,%xmm8				# cos *x4
+	mulsd	%xmm7,%xmm9				# sin *x3
+
+	mulsd	p_temp(%rsp),%xmm2		# low  0.5 * x2 * xx for sin term (cossin)
+	mulsd	p_temp1+8(%rsp),%xmm13		# high 0.5 * x2 * xx for sin term (sincos)
+
+	movsd	%xmm12,%xmm6				# Keep high r for cos term
+	movsd	%xmm3,%xmm7				# Keep low r for cos term
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12 	# -t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm3 	# -t=r-1.0
+
+	subsd	%xmm2,%xmm4				# sin - 0.5 * x2 *xx	(cossin)
+	subsd	%xmm13,%xmm9				# sin - 0.5 * x2 *xx	(sincos)
+
+	movhlps	%xmm0,%xmm10				# move high x for x*xx for cos term (cossin)
+	movhlps	%xmm1,%xmm11				# move high x for x for sin term    (sincos)
+
+	mulsd	p_temp+8(%rsp),%xmm10		# x * xx
+	mulsd	p_temp1(%rsp),%xmm1		# x * xx
+
+	movsd	%xmm12,%xmm2				# move -t for cos term
+	movsd	%xmm3,%xmm13				# move -t for cos term
+
+	addsd	.L__real_3ff0000000000000(%rip),%xmm12	# 1+(-t)
+	addsd	.L__real_3ff0000000000000(%rip),%xmm3 # 1+(-t)
+
+	addsd	p_temp(%rsp),%xmm4		# sin+xx	+
+	addsd	p_temp1+8(%rsp),%xmm9		# sin+xx	+
+
+	subsd	%xmm6,%xmm12				# (1-t) - r
+	subsd	%xmm7,%xmm3				# (1-t) - r
+
+	subsd	%xmm10,%xmm12				# ((1 + (-t)) - r) - x*xx
+	subsd	%xmm1,%xmm3				# ((1 + (-t)) - r) - x*xx
+
+	addsd	%xmm0,%xmm4				# sin + x	+
+	addsd	%xmm11,%xmm9				# sin + x	+
+
+	addsd   %xmm12,%xmm8				# cos+((1-t)-r - x*xx)
+	addsd   %xmm3,%xmm5				# cos+((1-t)-r - x*xx)
+
+	subsd   %xmm2,%xmm8				# cos+t
+	subsd   %xmm13,%xmm5				# cos+t
+
+	movlhps	%xmm8,%xmm4				# cossin
+	movlhps	%xmm9,%xmm5				# sincos
+
+	jmp	.L__vrd4_cos_cleanup
+
+.align 16
+.Lsincos_sincos_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	movapd	 %xmm6,p_temp(%rsp)		# Store rr
+	movapd	 %xmm7,p_temp1(%rsp)		# Store rr
+	movapd	 %xmm0,p_temp2(%rsp)		# Store r
+	movapd	 %xmm1,p_temp3(%rsp)		# Store r
+
+
+	movapd	.Lcossinarray+0x50(%rip),%xmm4		# s6
+	movapd	.Lcossinarray+0x50(%rip),%xmm5		# s6
+	movdqa	.Lcossinarray+0x20(%rip),%xmm8		# s3
+	movdqa	.Lcossinarray+0x20(%rip),%xmm9		# s3
+
+	movapd	%xmm2,%xmm10				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+
+	mulpd	%xmm2,%xmm4				# x2s6
+	mulpd	%xmm3,%xmm5				# x2s6
+	mulpd	%xmm2,%xmm8				# x2s3
+	mulpd	%xmm3,%xmm9				# x2s3
+
+	mulpd	%xmm2,%xmm10				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lcossinarray+0x40(%rip),%xmm4		# s5+x2s6
+	addpd	.Lcossinarray+0x40(%rip),%xmm5		# s5+x2s6
+	addpd	.Lcossinarray+0x10(%rip),%xmm8		# s2+x2s3
+	addpd	.Lcossinarray+0x10(%rip),%xmm9		# s2+x2s3
+
+	movapd	%xmm2,%xmm12				# move x2 for x6
+	movapd	%xmm3,%xmm13				# move x2 for x6
+
+	mulpd	%xmm2,%xmm4				# x2(s5+x2s6)
+	mulpd	%xmm3,%xmm5				# x2(s5+x2s6)
+	mulpd	%xmm2,%xmm8				# x2(s2+x2s3)
+	mulpd	%xmm3,%xmm9				# x2(s2+x2s3)
+
+	mulpd	%xmm10,%xmm12				# x6
+	mulpd	%xmm11,%xmm13				# x6
+
+	addpd	.Lcossinarray+0x30(%rip),%xmm4		# s4+x2(s5+x2s6)
+	addpd	.Lcossinarray+0x30(%rip),%xmm5		# s4+x2(s5+x2s6)
+	addpd	.Lcossinarray(%rip),%xmm8		# s1+x2(s2+x2s3)
+	addpd	.Lcossinarray(%rip),%xmm9		# s1+x2(s2+x2s3)
+
+	mulpd	%xmm12,%xmm4				# x6(s4+x2(s5+x2s6))
+	mulpd	%xmm13,%xmm5				# x6(s4+x2(s5+x2s6))
+
+	movhlps	%xmm2,%xmm6				# move low x2 for x3 for sin term
+	movhlps	%xmm3,%xmm7				# move low x2 for x3 for sin term
+	mulsd	p_temp2+8(%rsp),%xmm6		# get low x3 for sin term
+	mulsd	p_temp3+8(%rsp),%xmm7		# get low x3 for sin term
+
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for sin and cos terms
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for sin and cos terms
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm2,%xmm12				# move high 0.5*x2 for sin term
+	movhlps	%xmm3,%xmm13				# move high 0.5*x2 for sin term
+							# Reverse 12 and 2
+
+	movhlps	%xmm4,%xmm8				# xmm8 = sin , xmm4 = cos
+	movhlps	%xmm5,%xmm9				# xmm9 = sin , xmm5 = cos
+
+	mulsd	%xmm6,%xmm8				# sin *x3
+	mulsd	%xmm7,%xmm9				# sin *x3
+	mulsd	%xmm10,%xmm4				# cos *x4
+	mulsd	%xmm11,%xmm5				# cos *x4
+
+	mulsd	p_temp+8(%rsp),%xmm12		# 0.5 * x2 * xx for sin term
+	mulsd	p_temp1+8(%rsp),%xmm13		# 0.5 * x2 * xx for sin term
+	movsd	%xmm2,%xmm6				# Keep high r for cos term
+	movsd	%xmm3,%xmm7				# Keep high r for cos term
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm2 	# -t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm3 	# -t=r-1.0
+
+	subsd	%xmm12,%xmm8				# sin - 0.5 * x2 *xx
+	subsd	%xmm13,%xmm9				# sin - 0.5 * x2 *xx
+
+	movhlps	%xmm0,%xmm10				# move high x for x for sin term
+	movhlps	%xmm1,%xmm11				# move high x for x for sin term
+							# Reverse 10 and 0
+
+	mulsd	p_temp(%rsp),%xmm0		# x * xx
+	mulsd	p_temp1(%rsp),%xmm1		# x * xx
+
+	movsd	%xmm2,%xmm12				# move -t for cos term
+	movsd	%xmm3,%xmm13				# move -t for cos term
+
+	addsd	.L__real_3ff0000000000000(%rip),%xmm2 	# 1+(-t)
+	addsd	.L__real_3ff0000000000000(%rip),%xmm3 	# 1+(-t)
+	addsd	p_temp+8(%rsp),%xmm8			# sin+xx
+	addsd	p_temp1+8(%rsp),%xmm9			# sin+xx
+
+	subsd	%xmm6,%xmm2				# (1-t) - r
+	subsd	%xmm7,%xmm3				# (1-t) - r
+
+	subsd	%xmm0,%xmm2				# ((1 + (-t)) - r) - x*xx
+	subsd	%xmm1,%xmm3				# ((1 + (-t)) - r) - x*xx
+
+	addsd	%xmm10,%xmm8				# sin + x
+	addsd	%xmm11,%xmm9				# sin + x
+
+	addsd   %xmm2,%xmm4				# cos+((1-t)-r - x*xx)
+	addsd   %xmm3,%xmm5				# cos+((1-t)-r - x*xx)
+
+	subsd   %xmm12,%xmm4				# cos+t
+	subsd   %xmm13,%xmm5				# cos+t
+
+	movlhps	%xmm8,%xmm4
+	movlhps	%xmm9,%xmm5
+	jmp 	.L__vrd4_cos_cleanup
+
+.align 16
+.Lcossin_sincos_piby4:					# changed from sincos_sincos
+							# xmm1 is cossin and xmm0 is sincos
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	movapd	 %xmm6,p_temp(%rsp)		# Store rr
+	movapd	 %xmm7,p_temp1(%rsp)		# Store rr
+	movapd	 %xmm0,p_temp2(%rsp)		# Store r
+
+
+	movapd	.Lcossinarray+0x50(%rip),%xmm4		# s6
+	movapd	.Lsincosarray+0x50(%rip),%xmm5		# s6
+	movdqa	.Lcossinarray+0x20(%rip),%xmm8		# s3
+	movdqa	.Lsincosarray+0x20(%rip),%xmm9		# s3
+
+	movapd	%xmm2,%xmm10				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+
+	mulpd	%xmm2,%xmm4				# x2s6
+	mulpd	%xmm3,%xmm5				# x2s6
+	mulpd	%xmm2,%xmm8				# x2s3
+	mulpd	%xmm3,%xmm9				# x2s3
+
+	mulpd	%xmm2,%xmm10				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lcossinarray+0x40(%rip),%xmm4		# s5+x2s6
+	addpd	.Lsincosarray+0x40(%rip),%xmm5		# s5+x2s6
+	addpd	.Lcossinarray+0x10(%rip),%xmm8		# s2+x2s3
+	addpd	.Lsincosarray+0x10(%rip),%xmm9		# s2+x2s3
+
+	movapd	%xmm2,%xmm12				# move x2 for x6
+	movapd	%xmm3,%xmm13				# move x2 for x6
+
+	mulpd	%xmm2,%xmm4				# x2(s5+x2s6)
+	mulpd	%xmm3,%xmm5				# x2(s5+x2s6)
+	mulpd	%xmm2,%xmm8				# x2(s2+x2s3)
+	mulpd	%xmm3,%xmm9				# x2(s2+x2s3)
+
+	mulpd	%xmm10,%xmm12				# x6
+	mulpd	%xmm11,%xmm13				# x6
+
+	addpd	.Lcossinarray+0x30(%rip),%xmm4		# s4+x2(s5+x2s6)
+	addpd	.Lsincosarray+0x30(%rip),%xmm5		# s4+x2(s5+x2s6)
+	addpd	.Lcossinarray(%rip),%xmm8		# s1+x2(s2+x2s3)
+	addpd	.Lsincosarray(%rip),%xmm9		# s1+x2(s2+x2s3)
+
+	movhlps	%xmm11,%xmm11				# move high x4 for cos term	+
+
+	mulpd	%xmm12,%xmm4				# x6(s4+x2(s5+x2s6))
+	mulpd	%xmm13,%xmm5				# x6(s4+x2(s5+x2s6))
+
+	movhlps	%xmm2,%xmm6				# move low x2 for x3 for sin term
+	movsd	%xmm3,%xmm7				# move low x2 for x3 for sin term   	+
+	mulsd	p_temp2+8(%rsp),%xmm6		# get low x3 for sin term
+	mulsd	%xmm1,%xmm7				# get low x3 for sin term		+
+
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for sin and cos terms
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for sin and cos terms
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm2,%xmm12				# move high 0.5*x2 for sin term
+	movhlps	%xmm3,%xmm13				# move high r for cos
+
+	movhlps	%xmm4,%xmm8				# xmm8 = sin , xmm4 = cos
+	movhlps	%xmm5,%xmm9				# xmm9 = cos , xmm5 = sin
+
+	mulsd	%xmm6,%xmm8				# sin *x3
+	mulsd	%xmm11,%xmm9				# cos *x4
+	mulsd	%xmm10,%xmm4				# cos *x4
+	mulsd	%xmm7,%xmm5				# sin *x3
+
+	mulsd	p_temp+8(%rsp),%xmm12		# 0.5 * x2 * xx for sin term
+	mulsd	p_temp1(%rsp),%xmm3		# 0.5 * x2 * xx for sin term
+
+	movsd	%xmm2,%xmm6				# Keep high r for cos term
+	movsd	%xmm13,%xmm7				# Keep high r for cos term
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm2 	# -t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13 	# -t=r-1.0
+
+	subsd	%xmm12,%xmm8				# sin - 0.5 * x2 *xx
+	subsd	%xmm3,%xmm5				# sin - 0.5 * x2 *xx
+
+	movhlps	%xmm0,%xmm10				# move high x for x for sin term
+	movhlps	%xmm1,%xmm11				# move high x for x*xx for cos term
+
+	mulsd	p_temp(%rsp),%xmm0		# x * xx
+	mulsd	p_temp1+8(%rsp),%xmm11		# x * xx
+
+	movsd	%xmm2,%xmm12				# move -t for cos term
+	movsd	%xmm13,%xmm3				# move -t for cos term
+
+	addsd	.L__real_3ff0000000000000(%rip),%xmm2 	# 1+(-t)
+	addsd	.L__real_3ff0000000000000(%rip),%xmm13 	# 1+(-t)
+
+	addsd	p_temp+8(%rsp),%xmm8		# sin+xx
+	addsd	p_temp1(%rsp),%xmm5		# sin+xx
+
+	subsd	%xmm6,%xmm2				# (1-t) - r
+	subsd	%xmm7,%xmm13				# (1-t) - r
+
+	subsd	%xmm0,%xmm2				# ((1 + (-t)) - r) - x*xx
+	subsd	%xmm11,%xmm13				# ((1 + (-t)) - r) - x*xx
+
+
+	addsd	%xmm10,%xmm8				# sin + x
+	addsd	%xmm1,%xmm5				# sin + x
+
+	addsd   %xmm2,%xmm4				# cos+((1-t)-r - x*xx)
+	addsd   %xmm13,%xmm9				# cos+((1-t)-r - x*xx)
+
+	subsd   %xmm12,%xmm4				# cos+t
+	subsd   %xmm3,%xmm9				# cos+t
+
+	movlhps	%xmm8,%xmm4
+	movlhps	%xmm9,%xmm5
+	jmp 	.L__vrd4_cos_cleanup
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcoscos_sinsin_piby4:
+
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lsinarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lcosarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lsinarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lcosarray+0x20(%rip),%xmm9			# c3
+
+	movapd	 %xmm2,p_temp2(%rsp)			# store x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11	# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+	movapd	 %xmm11,p_temp3(%rsp)			# store r
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	mulpd	%xmm2,%xmm10					# x4
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0
+
+	movapd	%xmm2,%xmm12					# copy of x2 for 0.5*x2
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lsinarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lcosarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lsinarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lcosarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm11	# 1 + (-t)
+
+	mulpd	%xmm2,%xmm10					# x6
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm12	# 0.5 *x2
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lsinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lcosarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm10,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm0,%xmm2					# x3 recalculate
+	mulpd	%xmm3,%xmm3					# x4 recalculate
+
+	movapd   p_temp3(%rsp),%xmm13			# r
+
+	mulpd	%xmm6,%xmm12					# 0.5 * x2 *xx
+	mulpd	%xmm1,%xmm7					# x * xx
+
+	subpd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm3,%xmm5					# x4 * zc
+
+	subpd	%xmm12,%xmm4					# -0.5 * x2 *xx
+	subpd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	addpd	%xmm6,%xmm4					# x3 * zs +xx
+	addpd   %xmm11,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm13	# t relaculate, -t = r-1
+	addpd	%xmm0,%xmm4					# +x
+	subpd   %xmm13,%xmm5					# + t
+
+	jmp 	.L__vrd4_cos_cleanup
+
+.align 16
+.Lsinsin_coscos_piby4:
+
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lcosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lsinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lcosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lsinarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10	# r = 0.5 *x2
+	movapd	 %xmm3,p_temp3(%rsp)			# store x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+	movapd	 %xmm10,p_temp2(%rsp)			# store r
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0
+	mulpd	%xmm3,%xmm11					# x4
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for 0.5*x2
+
+	addpd	.Lcosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsinarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lcosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t)
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm11					# x6
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm13	# 0.5 *x2
+
+	addpd	.Lcosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lsinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm11,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zs
+
+	mulpd	%xmm2,%xmm2					# x4 recalculate
+	mulpd	%xmm1,%xmm3					# x3 recalculate
+
+	movapd   p_temp2(%rsp),%xmm12			# r
+
+	mulpd	%xmm0,%xmm6					# x * xx
+	mulpd	%xmm7,%xmm13					# 0.5 * x2 *xx
+	subpd   %xmm12,%xmm10					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x3 * zs
+
+	subpd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx;;;;;;;;;;;;;;;;;;;;;
+	subpd	%xmm13,%xmm5					# -0.5 * x2 *xx
+	addpd   %xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addpd	%xmm7,%xmm5					# +xx
+	subpd	.L__real_3ff0000000000000(%rip),%xmm12	# t relaculate, -t = r-1
+	addpd	%xmm1,%xmm5					# +x
+	subpd   %xmm12,%xmm4					# + t
+
+	jmp 	.L__vrd4_cos_cleanup
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcoscos_cossin_piby4:				#Derive from cossin_coscos
+	movapd	%xmm2,%xmm10					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lsincosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lcosarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lsincosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lcosarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# r
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+	movapd	 %xmm6,p_temp(%rsp)			# rr
+	movhlps	%xmm10,%xmm10					# get upper r for t for cos
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0  for cos
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lsincosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lcosarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lsincosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lcosarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addsd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t)
+	addpd   .L__real_3ff0000000000000(%rip),%xmm11	# 1 + (-t)
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lsincosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsincosarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lcosarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zc
+
+	movsd	%xmm0,%xmm8					# lower x for sin
+	mulsd	%xmm2,%xmm8					# lower x3 for sin
+
+	mulpd	%xmm2,%xmm2					# x4
+	mulpd	%xmm3,%xmm3					# upper x4 for cos
+	movsd	%xmm8,%xmm2					# lower x3 for sin
+
+	movsd	 %xmm6,%xmm9					# lower xx
+								# note using odd reg
+
+	movlpd   p_temp2+8(%rsp),%xmm12		# upper r for cos term
+	movapd   p_temp3(%rsp),%xmm13			# r
+
+	mulpd	%xmm0,%xmm6					# x * xx for upper cos term
+	mulpd	%xmm1,%xmm7					# x * xx
+	movhlps	%xmm6,%xmm6
+	mulsd	p_temp2(%rsp),%xmm9 			# xx * 0.5*x2 for sin term
+
+	subsd   %xmm12,%xmm10					# (1 + (-t)) - r
+	subpd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x4 * zc
+								# x3 * zs
+
+	movhlps	%xmm4,%xmm8					# xmm8= cos, xmm4= sin
+
+	subsd	%xmm9,%xmm4					# x3zs - 0.5*x2*xx
+
+	subsd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx
+	subpd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	addsd   %xmm10,%xmm8					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addpd   %xmm11,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp(%rsp),%xmm4			# +xx
+
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12	# -t = r-1
+	subpd	.L__real_3ff0000000000000(%rip),%xmm13	# -t = r-1
+
+	subsd   %xmm12,%xmm8					# + t
+	addsd	%xmm0,%xmm4					# +x
+	subpd   %xmm13,%xmm5					# + t
+
+	movlhps	%xmm8,%xmm4
+
+	jmp	.L__vrd4_cos_cleanup
+
+.align 16
+.Lcoscos_sincos_piby4:		#Derive from sincos_coscos
+	movapd	%xmm2,%xmm10					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lcossinarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lcosarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lcossinarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lcosarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10	# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11	# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# r
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+	movapd	 %xmm6,p_temp(%rsp)			# rr
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0 for cos
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lcossinarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lcosarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lcossinarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lcosarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addsd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t) for cos
+	addpd   .L__real_3ff0000000000000(%rip),%xmm11	# 1 + (-t)
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lcossinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lcossinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lcosarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zszc
+	addpd	%xmm9,%xmm5					# z
+
+	mulpd	%xmm0,%xmm2					# upper x3 for sin
+	mulsd	%xmm0,%xmm2					# lower x4 for cos
+	mulpd	%xmm3,%xmm3					# x4
+
+	movhlps	%xmm6,%xmm9					# upper xx for sin term
+								# note using odd reg
+
+	movlpd  p_temp2(%rsp),%xmm12			# lower r for cos term
+	movapd  p_temp3(%rsp),%xmm13			# r
+
+
+	mulpd	%xmm0,%xmm6					# x * xx for lower cos term
+	mulpd	%xmm1,%xmm7					# x * xx
+
+	mulsd	p_temp2+8(%rsp),%xmm9 			# xx * 0.5*x2 for upper sin term
+
+	subsd   %xmm12,%xmm10					# (1 + (-t)) - r
+	subpd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# lower=x4 * zc
+								# upper=x3 * zs
+	mulpd	%xmm3,%xmm5
+								# x4 * zc
+
+	movhlps	%xmm4,%xmm8					# xmm8= sin, xmm4= cos
+	subsd	%xmm9,%xmm8					# x3zs - 0.5*x2*xx
+
+
+	subsd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx
+	subpd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	addsd   %xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addpd   %xmm11,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp+8(%rsp),%xmm8			# +xx
+
+	movhlps	%xmm0,%xmm0					# upper x for sin
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12	# -t = r-1
+	subpd	.L__real_3ff0000000000000(%rip),%xmm13	# -t = r-1
+
+	subsd   %xmm12,%xmm4					# + t
+	subpd   %xmm13,%xmm5					# + t
+	addsd	%xmm0,%xmm8					# +x
+
+	movlhps	%xmm8,%xmm4
+
+	jmp 	.L__vrd4_cos_cleanup
+
+.align 16
+.Lcossin_coscos_piby4:
+	movapd	%xmm2,%xmm10					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lcosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lsincosarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lcosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lsincosarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# r
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+	movapd	 %xmm7,p_temp1(%rsp)			# rr
+	movhlps	%xmm11,%xmm11					# get upper r for t for cos
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0 for cos
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lcosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsincosarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lcosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsincosarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm10		# 1 + (-t)	;trash t
+	addsd   .L__real_3ff0000000000000(%rip),%xmm11		# 1 + (-t)	;trash t
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lcosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsincosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lsincosarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zcs
+
+	movsd	%xmm1,%xmm9					# lower x for sin
+	mulsd	%xmm3,%xmm9					# lower x3 for sin
+
+	mulpd	%xmm2,%xmm2					# x4
+	mulpd	%xmm3,%xmm3					# upper x4 for cos
+	movsd	%xmm9,%xmm3					# lower x3 for sin
+
+	movsd	 %xmm7,%xmm8					# lower xx
+								# note using even reg
+
+	movapd   p_temp2(%rsp),%xmm12			# r
+	movlpd   p_temp3+8(%rsp),%xmm13		# upper r for cos term
+
+	mulpd	%xmm0,%xmm6					# x * xx
+	mulpd	%xmm1,%xmm7					# x * xx for upper cos term
+	movhlps	%xmm7,%xmm7
+	mulsd	p_temp3(%rsp),%xmm8 			# xx * 0.5*x2 for sin term
+
+	subpd   %xmm12,%xmm10					# (1 + (-t)) - r
+	subsd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x4 * zc
+								# x3 * zs
+
+	movhlps	%xmm5,%xmm9					# xmm9= cos, xmm5= sin
+
+	subsd	%xmm8,%xmm5					# x3zs - 0.5*x2*xx
+
+	subpd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx
+	subsd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	addpd   %xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd   %xmm11,%xmm9					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp1(%rsp),%xmm5			# +xx
+
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm12		# t relaculate, -t = r-1
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13		# t relaculate, -t = r-1
+
+	subpd   %xmm12,%xmm4					# + t
+	subsd   %xmm13,%xmm9					# + t
+	addsd	%xmm1,%xmm5					# +x
+
+	movlhps	%xmm9,%xmm5
+
+	jmp 	.L__vrd4_cos_cleanup
+
+.align 16
+.Lcossin_sinsin_piby4:		# Derived from sincos_sinsin
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lsinarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lsincosarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lsinarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lsincosarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+	movapd	 %xmm7,p_temp1(%rsp)			# rr
+
+	movhlps	%xmm11,%xmm11
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0 for cos
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lsinarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsincosarray+0x40(%rip),%xmm5		# c5+x2c6
+	addpd	.Lsinarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsincosarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	mulpd	%xmm6,%xmm10					# 0.5*x2*xx
+	addsd   .L__real_3ff0000000000000(%rip),%xmm11	# 1 + (-t) for cos
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lsinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsincosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lsincosarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zczs
+
+	movsd	%xmm3,%xmm12
+	mulsd	%xmm1,%xmm12					# low x3 for sin
+
+	mulpd	%xmm0,%xmm2					# x3
+	mulpd	%xmm3,%xmm3					# high x4 for cos
+	movsd	%xmm12,%xmm3					# low x3 for sin
+
+	movhlps	%xmm1,%xmm8					# upper x for cos term
+								# note using even reg
+	movlpd  p_temp3+8(%rsp),%xmm13			# upper r for cos term
+
+	mulsd	p_temp1+8(%rsp),%xmm8			# x * xx for upper cos term
+
+	mulsd	p_temp3(%rsp),%xmm7 			# xx * 0.5*x2 for lower sin term
+
+	subsd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm3,%xmm5					# lower=x4 * zc
+								# upper=x3 * zs
+
+	movhlps	%xmm5,%xmm9					# xmm9= cos, xmm5= sin
+
+	subsd	%xmm7,%xmm5					# x3zs - 0.5*x2*xx
+
+	subsd   %xmm8,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	subpd	%xmm10,%xmm4					# x3*zs - 0.5*x2*xx
+	addsd   %xmm11,%xmm9					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp1(%rsp),%xmm5			# +xx
+
+	addpd	%xmm6,%xmm4					# +xx
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13	# -t = r-1
+
+
+	addsd	%xmm1,%xmm5					# +x
+	addpd	%xmm0,%xmm4					# +x
+	subsd   %xmm13,%xmm9					# + t
+
+	movlhps	%xmm9,%xmm5
+
+	jmp 	.L__vrd4_cos_cleanup
+
+.align 16
+.Lsincos_coscos_piby4:
+	movapd	%xmm2,%xmm10					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lcosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lcossinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lcosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lcossinarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# r
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+	movapd	 %xmm7,p_temp1(%rsp)			# rr
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0 for cos
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lcosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lcossinarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lcosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lcossinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t)
+	addsd   .L__real_3ff0000000000000(%rip),%xmm11	# 1 + (-t) for cos
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lcosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcossinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lcossinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zszc
+
+	mulpd	%xmm2,%xmm2					# x4
+	mulpd	%xmm1,%xmm3					# upper x3 for sin
+	mulsd	%xmm1,%xmm3					# lower x4 for cos
+
+	movhlps	%xmm7,%xmm8					# upper xx for sin term
+								# note using even reg
+
+	movapd  p_temp2(%rsp),%xmm12			# r
+	movlpd  p_temp3(%rsp),%xmm13			# lower r for cos term
+
+	mulpd	%xmm0,%xmm6					# x * xx
+	mulpd	%xmm1,%xmm7					# x * xx for lower cos term
+
+	mulsd	p_temp3+8(%rsp),%xmm8 			# xx * 0.5*x2 for upper sin term
+
+	subpd   %xmm12,%xmm10					# (1 + (-t)) - r
+	subsd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# lower=x4 * zc
+								# upper=x3 * zs
+
+	movhlps	%xmm5,%xmm9					# xmm9= sin, xmm5= cos
+
+	subsd	%xmm8,%xmm9					# x3zs - 0.5*x2*xx
+
+	subpd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx
+	subsd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	addpd   %xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd   %xmm11,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp1+8(%rsp),%xmm9			# +xx
+
+	movhlps	%xmm1,%xmm1					# upper x for sin
+	subpd	.L__real_3ff0000000000000(%rip),%xmm12	# -t = r-1
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13	# -t = r-1
+
+	subpd   %xmm12,%xmm4					# + t
+	subsd   %xmm13,%xmm5					# + t
+	addsd	%xmm1,%xmm9					# +x
+
+	movlhps	%xmm9,%xmm5
+
+	jmp 	.L__vrd4_cos_cleanup
+
+
+.align 16
+.Lsincos_sinsin_piby4:		# Derived from sincos_coscos
+	movapd	%xmm2,%xmm10					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lsinarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lcossinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lsinarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lcossinarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+	movapd	 %xmm7,p_temp1(%rsp)			# rr
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0 for cos
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lsinarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lcossinarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lsinarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lcossinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	mulpd	%xmm6,%xmm10					# 0.5x2*xx
+	addsd   .L__real_3ff0000000000000(%rip),%xmm11	# 1 + (-t) for cos
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lsinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcossinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lcossinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zszc
+
+	mulpd	%xmm0,%xmm2					# x3
+	mulpd	%xmm1,%xmm3					# upper x3 for sin
+	mulsd	%xmm1,%xmm3					# lower x4 for cos
+
+	movhlps	%xmm7,%xmm8					# upper xx for sin term
+								# note using even reg
+
+	movlpd  p_temp3(%rsp),%xmm13			# lower r for cos term
+
+	mulpd	%xmm1,%xmm7					# x * xx for lower cos term
+
+	mulsd	p_temp3+8(%rsp),%xmm8 			# xx * 0.5*x2 for upper sin term
+
+	subsd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm3,%xmm5					# lower=x4 * zc
+								# upper=x3 * zs
+
+	movhlps	%xmm5,%xmm9					# xmm9= sin, xmm5= cos
+
+	subsd	%xmm8,%xmm9					# x3zs - 0.5*x2*xx
+
+	subsd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	subpd	%xmm10,%xmm4					# x3*zs - 0.5*x2*xx
+	addsd   %xmm11,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp1+8(%rsp),%xmm9			# +xx
+
+	movhlps	%xmm1,%xmm1					# upper x for sin
+	addpd	%xmm6,%xmm4					# +xx
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13	# -t = r-1
+
+	addsd	%xmm1,%xmm9					# +x
+	addpd	%xmm0,%xmm4					# +x
+	subsd   %xmm13,%xmm5					# + t
+
+	movlhps	%xmm9,%xmm5
+
+	jmp 	.L__vrd4_cos_cleanup
+
+
+.align 16
+.Lsinsin_cossin_piby4:		# Derived from sincos_sinsin
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lsincosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lsinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lsincosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lsinarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10	# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11	# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# x2
+	movapd	 %xmm6,p_temp(%rsp)			# xx
+
+	movhlps	%xmm10,%xmm10
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0 for cos
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lsincosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsinarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lsincosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	mulpd	%xmm7,%xmm11					# 0.5*x2*xx
+	addsd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t) for cos
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lsincosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsincosarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lsinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zs
+
+
+	movsd	%xmm2,%xmm13
+	mulsd	%xmm0,%xmm13					# low x3 for sin
+
+	mulpd	%xmm1,%xmm3					# x3
+	mulpd	%xmm2,%xmm2					# high x4 for cos
+	movsd	%xmm13,%xmm2					# low x3 for sin
+
+
+	movhlps	%xmm0,%xmm9					# upper x for cos term								; note using even reg
+	movlpd  p_temp2+8(%rsp),%xmm12			# upper r for cos term
+	mulsd	p_temp+8(%rsp),%xmm9			# x * xx for upper cos term
+	mulsd	p_temp2(%rsp),%xmm6 			# xx * 0.5*x2 for lower sin term
+	subsd   %xmm12,%xmm10					# (1 + (-t)) - r
+	mulpd	%xmm3,%xmm5					# x3 * zs
+	mulpd	%xmm2,%xmm4					# lower=x4 * zc
+								# upper=x3 * zs
+
+	movhlps	%xmm4,%xmm8					# xmm8= cos, xmm4= sin
+	subsd	%xmm6,%xmm4					# x3zs - 0.5*x2*xx
+
+	subsd   %xmm9,%xmm10					# ((1 + (-t)) - r) - x*xx
+
+	subpd	%xmm11,%xmm5					# x3*zs - 0.5*x2*xx
+
+	addsd   %xmm10,%xmm8					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp(%rsp),%xmm4			# +xx
+
+	addpd	%xmm7,%xmm5					# +xx
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12	# -t = r-1
+
+	addsd	%xmm0,%xmm4					# +x
+	addpd	%xmm1,%xmm5					# +x
+	subsd   %xmm12,%xmm8					# + t
+	movlhps	%xmm8,%xmm4
+
+	jmp 	.L__vrd4_cos_cleanup
+
+.align 16
+.Lsinsin_sincos_piby4:		# Derived from sincos_coscos
+
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lcossinarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lsinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lcossinarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lsinarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# r
+	movapd	 %xmm6,p_temp(%rsp)			# rr
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0 for cos
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lcossinarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsinarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lcossinarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	mulpd	%xmm7,%xmm11					# 0.5x2*xx
+	addsd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t) for cos
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lcossinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lcossinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lsinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zszc
+
+	mulpd	%xmm1,%xmm3					# x3
+	mulpd	%xmm0,%xmm2					# upper x3 for sin
+	mulsd	%xmm0,%xmm2					# lower x4 for cos
+
+	movhlps	%xmm6,%xmm9					# upper xx for sin term
+								# note using even reg
+
+	movlpd  p_temp2(%rsp),%xmm12			# lower r for cos term
+
+	mulpd	%xmm0,%xmm6					# x * xx for lower cos term
+
+	mulsd	p_temp2+8(%rsp),%xmm9 			# xx * 0.5*x2 for upper sin term
+
+	subsd   %xmm12,%xmm10					# (1 + (-t)) - r
+
+	mulpd	%xmm3,%xmm5					# x3 * zs
+	mulpd	%xmm2,%xmm4					# lower=x4 * zc
+								# upper=x3 * zs
+
+	movhlps	%xmm4,%xmm8					# xmm9= sin, xmm5= cos
+
+	subsd	%xmm9,%xmm8					# x3zs - 0.5*x2*xx
+
+	subsd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx
+
+	subpd	%xmm11,%xmm5					# x3*zs - 0.5*x2*xx
+	addsd   %xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp+8(%rsp),%xmm8			# +xx
+
+	movhlps	%xmm0,%xmm0					# upper x for sin
+	addpd	%xmm7,%xmm5					# +xx
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12	# -t = r-1
+
+
+	addsd	%xmm0,%xmm8					# +x
+	addpd	%xmm1,%xmm5					# +x
+	subsd   %xmm12,%xmm4					# + t
+
+	movlhps	%xmm8,%xmm4
+
+	jmp 	.L__vrd4_cos_cleanup
+
+
+.align 16
+.Lsinsin_sinsin_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lsinarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lsinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lsinarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lsinarray+0x20(%rip),%xmm9			# c3
+
+	movapd	 %xmm2,p_temp2(%rsp)			# copy of x2
+	movapd	 %xmm3,p_temp3(%rsp)			# copy of x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	mulpd	%xmm2,%xmm10					# x4
+	mulpd	%xmm3,%xmm11					# x4
+
+	addpd	.Lsinarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsinarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lsinarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	mulpd	%xmm2,%xmm10					# x6
+	mulpd	%xmm3,%xmm11					# x6
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm2		# 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm3		# 0.5 *x2
+
+	addpd	.Lsinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lsinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm6,%xmm2					# 0.5 * x2 *xx
+	mulpd	%xmm7,%xmm3					# 0.5 * x2 *xx
+
+	mulpd	%xmm10,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm11,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zs
+
+	movapd	p_temp2(%rsp),%xmm10			# x2
+	movapd	p_temp3(%rsp),%xmm11			# x2
+
+	mulpd	%xmm0,%xmm10					# x3
+	mulpd	%xmm1,%xmm11					# x3
+
+	mulpd	%xmm10,%xmm4					# x3 * zs
+	mulpd	%xmm11,%xmm5					# x3 * zs
+
+	subpd	%xmm2,%xmm4					# -0.5 * x2 *xx
+	subpd	%xmm3,%xmm5					# -0.5 * x2 *xx
+
+	addpd	%xmm6,%xmm4					# +xx
+	addpd	%xmm7,%xmm5					# +xx
+
+	addpd	%xmm0,%xmm4					# +x
+	addpd	%xmm1,%xmm5					# +x
+
+	jmp 	.L__vrd4_cos_cleanup
diff --git a/src/gas/vrd4exp.S b/src/gas/vrd4exp.S
new file mode 100644
index 0000000..a05af8b
--- /dev/null
+++ b/src/gas/vrd4exp.S
@@ -0,0 +1,502 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrd4exp.s
+#
+# A vector implementation of the exp libm function.
+#
+# Prototype:
+#
+#    __m128d,__m128d __vrd4_exp(__m128d x1, __m128d x2);
+#
+#   Computes e raised to the x power for an array of input values.
+#   Places the results into the supplied y array.
+# Does not perform error checking.   Denormal results are truncated to 0.
+#
+# This routine computes 4 double precision exponent values at a time.
+# The four values are passed as packed doubles in xmm0 and xmm1.
+# The four results are returned as packed doubles in xmm0 and xmm1.
+# Note that this represents a non-standard ABI usage, as no ABI
+# ( and indeed C) currently allows returning 2 values for a function.
+# It is expected that some compilers may be able to take advantage of this
+# interface when implementing vectorized loops.  Using the array implementation
+# of the routine requires putting the inputs into memory, and retrieving
+# the results from memory.  This routine eliminates the need for this
+# overhead if the data does not already reside in memory.
+# This routine is derived directly from the array version.
+#
+#
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+# define local variable storage offsets
+.equ	p_temp,0		# temporary for get/put bits operation
+.equ	p_temp1,0x10		# temporary for exponent multiply
+
+.equ	save_rbx,0x020		#qword
+.equ	save_rdi,0x028		#qword
+
+.equ	save_rsi,0x030		#qword
+
+
+
+.equ	p2_temp,0x40		# second temporary for get/put bits operation
+.equ	p2_temp1,0x60		# second temporary for exponent multiply
+
+
+.equ	stack_size,0x088
+
+
+# parameters are passed in by Linux as:
+# xmm0 - __m128d x1
+# xmm1 - __m128d x2
+
+    .text
+    .align 16
+    .p2align 4,,15
+.globl __vrd4_exp
+    .type   __vrd4_exp,@function
+__vrd4_exp:
+	sub		$stack_size,%rsp
+	mov		%rbx,save_rbx(%rsp)	# save rdi
+		movapd	%xmm1,%xmm6
+
+# process 4 values at a time.
+
+	movapd	.L__real_thirtytwo_by_log2(%rip),%xmm3	#
+
+#      Step 1. Reduce the argument.
+#        /* Find m, z1 and z2 such that exp(x) = 2**m * (z1 + z2) */
+#    r = x * thirtytwo_by_logbaseof2;
+		movapd	%xmm3,%xmm7
+	movapd	 %xmm0,p_temp(%rsp)
+	maxpd	.L__real_C0F0000000000000(%rip),%xmm0	# protect against very large negative, non-infinite numbers
+	mulpd	%xmm0,%xmm3
+
+		movapd	 %xmm6,p2_temp(%rsp)
+		maxpd	.L__real_C0F0000000000000(%rip),%xmm6
+		mulpd	%xmm6,%xmm7
+
+# save x for later.
+        minpd   .L__real_40F0000000000000(%rip),%xmm3    # protect against very large, non-infinite numbers
+
+
+#    /* Set n = nearest integer to r */
+	cvtpd2dq	%xmm3,%xmm4
+	lea		.L__two_to_jby32_lead_table(%rip),%rdi
+	lea		.L__two_to_jby32_trail_table(%rip),%rsi
+	cvtdq2pd	%xmm4,%xmm1
+        	minpd   .L__real_40F0000000000000(%rip),%xmm7    # protect against very large, non-infinite numbers
+
+ #    r1 = x - n * logbaseof2_by_32_lead;
+	movapd	.L__real_log2_by_32_lead(%rip),%xmm2	#
+	mulpd	%xmm1,%xmm2					#
+	movq	 %xmm4,p_temp1(%rsp)
+	subpd	%xmm2,%xmm0					# r1 in xmm0,
+
+		cvtpd2dq	%xmm7,%xmm2
+		cvtdq2pd	%xmm2,%xmm8
+
+#    r2 =   - n * logbaseof2_by_32_trail;
+	mulpd	.L__real_log2_by_32_tail(%rip),%xmm1	# r2 in xmm1
+#    j = n & 0x0000001f;
+	mov		$0x01f,%r9
+	mov		%r9,%r8
+	mov		p_temp1(%rsp),%ecx
+	and		%ecx,%r9d
+		movq	 %xmm2,p2_temp1(%rsp)
+		movapd	.L__real_log2_by_32_lead(%rip),%xmm9
+		mulpd	%xmm8,%xmm9
+		subpd	%xmm9,%xmm6				# r1b in xmm6
+		mulpd	.L__real_log2_by_32_tail(%rip),%xmm8	# r2b in xmm8
+
+	mov             p_temp1+4(%rsp),%edx
+	and		%edx,%r8d
+#    f1 = two_to_jby32_lead_table[j];
+#    f2 = two_to_jby32_trail_table[j];
+
+#    *m = (n - j) / 32;
+	sub		%r9d,%ecx
+	sar		$5,%ecx					#m
+	sub		%r8d,%edx
+	sar		$5,%edx
+
+
+	movapd	%xmm0,%xmm2
+	addpd	%xmm1,%xmm2   # r = r1 + r2
+
+		mov		$0x01f,%r11
+		mov		%r11,%r10
+		mov		p2_temp1(%rsp),%ebx
+		and		%ebx,%r11d
+#      Step 2. Compute the polynomial.
+#    q = r1 + (r2 +
+#              r*r*( 5.00000000000000008883e-01 +
+#                      r*( 1.66666666665260878863e-01 +
+#                      r*( 4.16666666662260795726e-02 +
+#                      r*( 8.33336798434219616221e-03 +
+#                      r*( 1.38889490863777199667e-03 ))))));
+#    q = r + r^2/2 + r^3/6 + r^4/24 + r^5/120 + r^6/720
+	movapd	%xmm2,%xmm1
+	movapd	.L__real_3f56c1728d739765(%rip),%xmm3	# 	1/720
+	movapd	.L__real_3FC5555555548F7C(%rip),%xmm0	# 	1/6
+# deal with infinite results
+	mov		$1024,%rax
+	movsx	%ecx,%rcx
+	cmp		%rax,%rcx
+
+	mulpd	%xmm2,%xmm3						# *x
+	mulpd	%xmm2,%xmm0						# *x
+	mulpd	%xmm2,%xmm1						# x*x
+	movapd	%xmm1,%xmm4
+
+	cmovg	%rax,%rcx				## if infinite, then set rcx to multiply
+							# by infinity
+	movsx	%edx,%rdx
+	cmp		%rax,%rdx
+
+		movapd	%xmm6,%xmm9
+		addpd	%xmm8,%xmm9  #  rb = r1b + r2b
+	addpd	.L__real_3F811115B7AA905E(%rip),%xmm3	# 	+ 1/120
+	addpd	.L__real_3fe0000000000000(%rip),%xmm0	# 	+ .5
+	mulpd	%xmm1,%xmm4						# x^4
+	mulpd	%xmm2,%xmm3						# *x
+
+	cmovg	%rax,%rdx				## if infinite, then set rcx to multiply
+							# by infinity
+# deal with denormal results
+	xor		%rax,%rax
+	add		$1023,%rcx				# add bias
+
+	mulpd	%xmm1,%xmm0					# *x^2
+	addpd	.L__real_3FA5555555545D4E(%rip),%xmm3	# 	+ 1/24
+	addpd	%xmm2,%xmm0					# 	+ x
+	mulpd	%xmm4,%xmm3					# *x^4
+
+# check for infinity or nan
+	movapd	p_temp(%rsp),%xmm2
+
+	cmovs	%rax,%rcx				## if denormal, then multiply by 0
+	shl		$52,%rcx				# build 2^n
+
+		sub		%r11d,%ebx
+		movapd	%xmm9,%xmm1
+	addpd	%xmm3,%xmm0					# q = final sum
+		movapd	.L__real_3f56c1728d739765(%rip),%xmm7	# 	1/720
+		movapd	.L__real_3FC5555555548F7C(%rip),%xmm3	# 	1/6
+
+#    *z2 = f2 + ((f1 + f2) * q);
+        movlpd  (%rsi,%r9,8),%xmm5              # f2
+        movlpd  (%rsi,%r8,8),%xmm4              # f2
+        addsd   (%rdi,%r8,8),%xmm4              # f1 + f2
+        addsd   (%rdi,%r9,8),%xmm5              # f1 + f2
+                mov p2_temp1+4(%rsp),%r8d
+		and		%r8d,%r10d
+		sar		$5,%ebx					#m
+		mulpd	%xmm9,%xmm7					# *x
+		mulpd	%xmm9,%xmm3					# *x
+		mulpd	%xmm9,%xmm1					# x*x
+		sub		%r10d,%r8d
+		sar		$5,%r8d
+# check for infinity or nan
+	andpd	.L__real_infinity(%rip),%xmm2
+	cmppd   $0,.L__real_infinity(%rip),%xmm2
+	add		$1023,%rdx				# add bias
+	shufpd	$0,%xmm4,%xmm5
+		movapd	%xmm1,%xmm4
+
+	cmovs	%rax,%rdx				## if denormal, then multiply by 0
+	shl		$52,%rdx					# build 2^n
+
+	mulpd	%xmm5,%xmm0
+	mov		 %rcx,p_temp1(%rsp) # get 2^n to memory
+	mov		 %rdx,p_temp1+8(%rsp) # get 2^n to memory
+	addpd	%xmm5,%xmm0					#z = z1 + z2
+		mov		$1024,%rax
+		movsx	%ebx,%rbx
+		cmp		%rax,%rbx
+# end of splitexp
+#        /* Scale (z1 + z2) by 2.0**m */
+#          r = scaleDouble_1(z, n);
+
+
+		cmovg	%rax,%rbx			## if infinite, then set rcx to multiply
+							# by infinity
+		movsx	%r8d,%rdx
+		cmp		%rax,%rdx
+
+	movmskpd	%xmm2,%r8d
+
+		addpd	.L__real_3F811115B7AA905E(%rip),%xmm7	# 	+ 1/120
+		addpd	.L__real_3fe0000000000000(%rip),%xmm3	# 	+ .5
+		mulpd	%xmm1,%xmm4				# x^4
+		mulpd	%xmm9,%xmm7				# *x
+		cmovg	%rax,%rdx			## if infinite, then set rcx to multiply
+
+
+		xor		%rax,%rax
+		add		$1023,%rbx		# add bias
+
+		mulpd	%xmm1,%xmm3			# *x^2
+		addpd	.L__real_3FA5555555545D4E(%rip),%xmm7	# 	+ 1/24
+		addpd	%xmm9,%xmm3			# 	+ x
+		mulpd	%xmm4,%xmm7			# *x^4
+
+		cmovs	%rax,%rbx			## if denormal, then multiply by 0
+		shl		$52,%rbx		# build 2^n
+
+#      Step 3. Reconstitute.
+
+	mulpd	p_temp1(%rsp),%xmm0	# result *= 2^n
+		addpd	%xmm7,%xmm3			# q = final sum
+
+                movlpd  (%rsi,%r11,8),%xmm5             # f2
+                movlpd  (%rsi,%r10,8),%xmm4             # f2
+                addsd   (%rdi,%r10,8),%xmm4             # f1 + f2
+                addsd   (%rdi,%r11,8),%xmm5             # f1 + f2
+
+		add		$1023,%rdx		# add bias
+		cmovs	%rax,%rdx			## if denormal, then multiply by 0
+		shufpd	$0,%xmm4,%xmm5
+		shl		$52,%rdx		# build 2^n
+
+		mulpd	%xmm5,%xmm3
+		mov		 %rbx,p2_temp1(%rsp) # get 2^n to memory
+		mov		 %rdx,p2_temp1+8(%rsp) # get 2^n to memory
+		addpd	%xmm5,%xmm3			#z = z1 + z2
+
+		movapd	p2_temp(%rsp),%xmm2
+		andpd	.L__real_infinity(%rip),%xmm2
+		cmppd	$0,.L__real_infinity(%rip),%xmm2
+		movmskpd	%xmm2,%ebx
+	test		$3,%r8d
+		mulpd	p2_temp1(%rsp),%xmm3	# result *= 2^n
+# we'd like to avoid a branch, and can use cmp's and and's to
+# eliminate them.  But it adds cycles for normal cases which
+# are supposed to be exceptions.  Using this branch with the
+# check above results in faster code for the normal cases.
+	jnz			.L__exp_naninf
+
+.L__vda_bottom1:
+# store the result _m128d
+		test		$3,%ebx
+		jnz		.L__exp_naninf2
+
+.L__vda_bottom2:
+
+	movapd	%xmm3,%xmm1
+
+
+#
+#
+.L__final_check:
+	mov		save_rbx(%rsp),%rbx		# restore rbx
+	add		$stack_size,%rsp
+	ret
+
+# at least one of the numbers needs special treatment
+.L__exp_naninf:
+	lea		p_temp(%rsp),%rcx
+	call  .L__naninf
+	jmp		.L__vda_bottom1
+.L__exp_naninf2:
+	lea		p2_temp(%rsp),%rcx
+	mov			%ebx,%r8d
+	movapd	%xmm0,%xmm4
+	movapd	%xmm3,%xmm0
+	call  .L__naninf
+	movapd	%xmm0,%xmm3
+	movapd	%xmm4,%xmm0
+	jmp		.L__vda_bottom2
+
+# This subroutine checks a double pair for nans and infinities and
+# produces the proper result from the exceptional inputs
+# Register assumptions:
+# Inputs:
+# r8d - mask of errors
+# xmm0 - computed result vector
+# rcx - pointing to memory image of inputs
+# Outputs:
+# xmm0 - new result vector
+# %rax,rdx,,%xmm2 all modified.
+.L__naninf:
+# check the first number
+	test	$1,%r8d
+	jz		.L__check2
+
+	mov		(%rcx),%rdx
+	mov		$0x0000FFFFFFFFFFFFF,%rax
+	test	%rax,%rdx
+	jnz		.L__enan1			# jump if mantissa not zero, so it's a NaN
+# inf
+	mov		%rdx,%rax
+	rcl		$1,%rax
+	jnc		.L__r1				# exp(+inf) = inf
+	xor		%rdx,%rdx				# exp(-inf) = 0
+	jmp		.L__r1
+
+#NaN
+.L__enan1:
+	mov		$0x00008000000000000,%rax	# convert to quiet
+	or		%rax,%rdx
+.L__r1:
+	movd	%rdx,%xmm2
+	shufpd	$2,%xmm0,%xmm2
+	movsd	%xmm2,%xmm0
+# check the second number
+.L__check2:
+	test	$2,%r8d
+	jz		.L__r3
+	mov		8(%rcx),%rdx
+	mov		$0x0000FFFFFFFFFFFFF,%rax
+	test	%rax,%rdx
+	jnz		.L__enan2			# jump if mantissa not zero, so it's a NaN
+# inf
+	mov		%rdx,%rax
+	rcl		$1,%rax
+	jnc		.L__r2				# exp(+inf) = inf
+	xor		%rdx,%rdx				# exp(-inf) = 0
+	jmp		.L__r2
+
+#NaN
+.L__enan2:
+	mov		$0x00008000000000000,%rax	# convert to quiet
+	or		%rax,%rdx
+.L__r2:
+	movd	%rdx,%xmm2
+	shufpd	$0,%xmm2,%xmm0
+.L__r3:
+	ret
+
+	.data
+	.align	64
+
+.L__real_3ff0000000000000: 	.quad 0x03ff0000000000000	# 1.0
+				.quad 0x03ff0000000000000
+.L__real_4040000000000000:	.quad 0x04040000000000000	# 32
+				.quad 0x04040000000000000
+.L__real_40F0000000000000:      .quad 0x040F0000000000000        # 65536, to protect against really large numbers
+                                .quad 0x040F0000000000000
+.L__real_C0F0000000000000:	.quad 0x0C0F0000000000000	# -65536, to protect against really large negative numbers
+				.quad 0x0C0F0000000000000
+.L__real_3FA0000000000000:	.quad 0x03FA0000000000000	# 1/32
+				.quad 0x03FA0000000000000
+.L__real_3fe0000000000000:	.quad 0x03fe0000000000000	# 1/2
+				.quad 0x03fe0000000000000
+.L__real_infinity:		.quad 0x07ff0000000000000	#
+				.quad 0x07ff0000000000000
+.L__real_ninfinity:		.quad 0x0fff0000000000000	#
+				.quad 0x0fff0000000000000
+.L__real_thirtytwo_by_log2: 	.quad 0x040471547652b82fe	# thirtytwo_by_log2
+				.quad 0x040471547652b82fe
+.L__real_log2_by_32_lead:  	.quad 0x03f962e42fe000000	# log2_by_32_lead
+				.quad 0x03f962e42fe000000
+.L__real_log2_by_32_tail:  	.quad 0x0Bdcf473de6af278e	# -log2_by_32_tail
+				.quad 0x0Bdcf473de6af278e
+.L__real_3f56c1728d739765:	.quad 0x03f56c1728d739765	# 1.38889490863777199667e-03
+				.quad 0x03f56c1728d739765
+.L__real_3F811115B7AA905E:	.quad 0x03F811115B7AA905E	# 8.33336798434219616221e-03
+				.quad 0x03F811115B7AA905E
+.L__real_3FA5555555545D4E:	.quad 0x03FA5555555545D4E	# 4.16666666662260795726e-02
+				.quad 0x03FA5555555545D4E
+.L__real_3FC5555555548F7C:	.quad 0x03FC5555555548F7C	# 1.66666666665260878863e-01
+				.quad 0x03FC5555555548F7C
+
+
+.L__two_to_jby32_lead_table:
+	.quad	0x03ff0000000000000 # 1
+	.quad	0x03ff059b0d0000000		# 1.0219
+	.quad	0x03ff0b55860000000		# 1.04427
+	.quad	0x03ff11301d0000000		# 1.06714
+	.quad	0x03ff172b830000000		# 1.09051
+	.quad	0x03ff1d48730000000		# 1.11439
+	.quad	0x03ff2387a60000000		# 1.13879
+	.quad	0x03ff29e9df0000000		# 1.16372
+	.quad	0x03ff306fe00000000		# 1.18921
+	.quad	0x03ff371a730000000		# 1.21525
+	.quad	0x03ff3dea640000000		# 1.24186
+	.quad	0x03ff44e0860000000		# 1.26905
+	.quad	0x03ff4bfdad0000000		# 1.29684
+	.quad	0x03ff5342b50000000		# 1.32524
+	.quad	0x03ff5ab07d0000000		# 1.35426
+	.quad	0x03ff6247eb0000000		# 1.38391
+	.quad	0x03ff6a09e60000000		# 1.41421
+	.quad	0x03ff71f75e0000000		# 1.44518
+	.quad	0x03ff7a11470000000		# 1.47683
+	.quad	0x03ff8258990000000		# 1.50916
+	.quad	0x03ff8ace540000000		# 1.54221
+	.quad	0x03ff93737b0000000		# 1.57598
+	.quad	0x03ff9c49180000000		# 1.61049
+	.quad	0x03ffa5503b0000000		# 1.64576
+	.quad	0x03ffae89f90000000		# 1.68179
+	.quad	0x03ffb7f76f0000000		# 1.71862
+	.quad	0x03ffc199bd0000000		# 1.75625
+	.quad	0x03ffcb720d0000000		# 1.79471
+	.quad	0x03ffd5818d0000000		# 1.83401
+	.quad	0x03ffdfc9730000000		# 1.87417
+	.quad	0x03ffea4afa0000000		# 1.91521
+	.quad	0x03fff507650000000		# 1.95714
+	.quad 0					# for alignment
+.L__two_to_jby32_trail_table:
+	.quad	0x00000000000000000 # 0
+	.quad	0x03e48ac2ba1d73e2a		# 1.1489e-008
+	.quad	0x03e69f3121ec53172		# 4.83347e-008
+	.quad	0x03df25b50a4ebbf1b		# 2.67125e-010
+	.quad	0x03e68faa2f5b9bef9		# 4.65271e-008
+	.quad	0x03e368b9aa7805b80		# 5.24924e-009
+	.quad	0x03e6ceac470cd83f6		# 5.38622e-008
+	.quad	0x03e547f7b84b09745		# 1.90902e-008
+	.quad	0x03e64636e2a5bd1ab		# 3.79764e-008
+	.quad	0x03e5ceaa72a9c5154		# 2.69307e-008
+	.quad	0x03e682468446b6824		# 4.49684e-008
+	.quad	0x03e18624b40c4dbd0		# 1.41933e-009
+	.quad	0x03e54d8a89c750e5e		# 1.94147e-008
+	.quad	0x03e5a753e077c2a0f		# 2.46409e-008
+	.quad	0x03e6a90a852b19260		# 4.94813e-008
+	.quad	0x03e0d2ac258f87d03		# 8.48872e-010
+	.quad	0x03e59fcef32422cbf		# 2.42032e-008
+	.quad	0x03e61d8bee7ba46e2		# 3.3242e-008
+	.quad	0x03e4f580c36bea881		# 1.45957e-008
+	.quad	0x03e62999c25159f11		# 3.46453e-008
+	.quad	0x03e415506dadd3e2a		# 8.0709e-009
+	.quad	0x03e29b8bc9e8a0388		# 2.99439e-009
+	.quad	0x03e451f8480e3e236		# 9.83622e-009
+	.quad	0x03e41f12ae45a1224		# 8.35492e-009
+	.quad	0x03e62b5a75abd0e6a		# 3.48493e-008
+	.quad	0x03e47daf237553d84		# 1.11085e-008
+	.quad	0x03e6b0aa538444196		# 5.03689e-008
+	.quad	0x03e69df20d22a0798		# 4.81896e-008
+	.quad	0x03e69f7490e4bb40b		# 4.83654e-008
+	.quad	0x03e4bdcdaf5cb4656		# 1.29746e-008
+	.quad	0x03e452486cc2c7b9d		# 9.84533e-009
+	.quad	0x03e66dc8a80ce9f09		# 4.25828e-008
+	.quad 0					# for alignment
+
+
+
diff --git a/src/gas/vrd4frcpa.S b/src/gas/vrd4frcpa.S
new file mode 100644
index 0000000..3ae0b91
--- /dev/null
+++ b/src/gas/vrd4frcpa.S
@@ -0,0 +1,1181 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrd4frcpa.asm
+#
+# A vector implementation of the floating point reciprocal approximation function.
+# The goal is to be faster than a divide.  This routine provides four double
+# precision results from four double precision inputs.  It would not be necessary
+## if SSE defined a double precision instruction similar to the single precision
+# rcpss.
+#
+# Prototype:
+#
+#    __m128d,__m128d __vrd4_frcpa(__m128d x1, __m128d x2);
+#
+#   Computes an approximate reciprocal of x.
+#   A table lookup is performed on the higher 10 bits of the mantissa
+#   (not including the implicit bit).
+#
+#
+#
+# This routine computes 4 double precision frcpa values at a time.
+# The four values are passed as packed doubles in xmm0 and xmm1.
+# The four results are returned as packed doubles in xmm0 and xmm1.
+# Note that this represents a non-standard ABI usage, as no ABI
+# ( and indeed C) currently allows returning 2 values for a function.
+# It is expected that some compilers may be able to take advantage of this
+# interface when implementing vectorized loops.
+#
+
+
+# define local variable storage offsets
+.equ	p_x,0		# temporary for get/put bits operation
+.equ	p_x2,0x10		# temporary for get/put bits operation
+
+.equ	stack_size,0x028
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+
+# parameters are expected as:
+# xmm0 - __m128d x1
+# xmm1 - __m128d x2
+
+    .text
+    .align 16
+    .p2align 4,,15
+.globl __vrd4_frcpa
+    .type   __vrd4_frcpa,@function
+__vrd4_frcpa:
+	sub		$stack_size,%rsp
+# 10 bit GPR method
+	xor		%rax,%rax
+	movdqa	.L__mask_expext(%rip),%xmm3
+		movdqa	%xmm1,%xmm6
+	movdqa	%xmm0,%xmm4
+		movdqa	%xmm3,%xmm5
+## if 1/2 bit set, increment the index+exponent
+	psrlq	$41,%xmm4
+		psrlq	$41,%xmm6
+	movdqa	%xmm4,%xmm2
+	paddq	.L__int_one(%rip),%xmm4
+	psrlq	$1,%xmm4
+	pand	.L__mask_10bits(%rip),%xmm4
+#  invert the exponent
+	psubq	%xmm2,%xmm3
+		movdqa	%xmm6,%xmm2
+		paddq	.L__int_one(%rip),%xmm6
+		psrlq	$1,%xmm6
+		pand	.L__mask_10bits(%rip),%xmm6
+		psubq	%xmm2,%xmm5
+	pand	.L__mask_expext2(%rip),%xmm3
+		pand	.L__mask_expext2(%rip),%xmm5
+	psllq	$1,%xmm3
+# do the lookup	 and recombine
+	lea		.L__rcp_table(%rip),%rdx
+
+	movdqa	%xmm4,p_x(%rsp)	# move the indexes to a memory location
+		psllq	$1,%xmm5
+	mov		p_x(%rsp),%r8		# 3 cycles faster for frcpa, but 2 cycles slower for log
+	mov		p_x+8(%rsp),%r9
+		movdqa	%xmm6,p_x2(%rsp)	# move the indexes to a memory location
+	movd	(%rdx,%r9,4),%xmm2  	# lookup
+	movd	(%rdx,%r8,4),%xmm4  	# lookup
+	pslldq	$8,%xmm2						# shift by 8 bytes
+	por		%xmm4,%xmm2
+	por		%xmm2,%xmm3
+		mov		p_x2(%rsp),%r8		# 3 cycles faster for frcpa, but 2 cycles slower for log
+		mov		p_x2+8(%rsp),%r9
+		movd	(%rdx,%r9,4),%xmm2  	# lookup
+		movd	(%rdx,%r8,4),%xmm4  	# lookup
+		pslldq	$8,%xmm2						# shift by 8 bytes
+		por		%xmm4,%xmm2
+		por		%xmm2,%xmm5
+# shift and restore the sign
+	pand	.L__mask_sign(%rip),%xmm0
+		pand	.L__mask_sign(%rip),%xmm1
+	psllq	$40,%xmm3
+		psllq	$40,%xmm5
+	por		%xmm3,%xmm0
+		por		%xmm5,%xmm1
+	add		$stack_size,%rsp
+	ret
+
+
+        .data
+        .align  16
+
+.L__int_one:		.quad 0x00000000000000001
+			.quad 0x00000000000000001
+
+.L__mask_10bits:	.quad 0x000000000000003ff
+			.quad 0x000000000000003ff
+
+.L__mask_expext:	.quad 0x000000000003ff000
+			.quad 0x000000000003ff000
+
+.L__mask_expext2:	.quad 0x000000000003ff800
+			.quad 0x000000000003ff800
+
+.L__mask_sign:		.quad 0x08000000000000000
+			.quad 0x08000000000000000
+
+.L__real_one:		.quad 0x03ff0000000000000
+			.quad 0x03ff0000000000000
+.L__real_two:		.quad 0x04000000000000000
+			.quad 0x04000000000000000
+
+        .align  16
+
+.L__rcp_table:
+   .long   0x0000
+   .long   0x0FF8
+   .long   0x0FF0
+   .long   0x0FE8
+   .long   0x0FE0
+   .long   0x0FD8
+   .long   0x0FD0
+   .long   0x0FC8
+   .long   0x0FC0
+   .long   0x0FB8
+   .long   0x0FB1
+   .long   0x0FA9
+   .long   0x0FA1
+   .long   0x0F99
+   .long   0x0F91
+   .long   0x0F89
+   .long   0x0F82
+   .long   0x0F7A
+   .long   0x0F72
+   .long   0x0F6B
+   .long   0x0F63
+   .long   0x0F5B
+   .long   0x0F53
+   .long   0x0F4C
+   .long   0x0F44
+   .long   0x0F3D
+   .long   0x0F35
+   .long   0x0F2D
+   .long   0x0F26
+   .long   0x0F1E
+   .long   0x0F17
+   .long   0x0F0F
+   .long   0x0F08
+   .long   0x0F00
+   .long   0x0EF8
+   .long   0x0EF1
+   .long   0x0EEA
+   .long   0x0EE2
+   .long   0x0EDB
+   .long   0x0ED3
+   .long   0x0ECC
+   .long   0x0EC4
+   .long   0x0EBD
+   .long   0x0EB6
+   .long   0x0EAE
+   .long   0x0EA7
+   .long   0x0EA0
+   .long   0x0E98
+   .long   0x0E91
+   .long   0x0E8A
+   .long   0x0E82
+   .long   0x0E7B
+   .long   0x0E74
+   .long   0x0E6D
+   .long   0x0E65
+   .long   0x0E5E
+   .long   0x0E57
+   .long   0x0E50
+   .long   0x0E49
+   .long   0x0E41
+   .long   0x0E3A
+   .long   0x0E33
+   .long   0x0E2C
+   .long   0x0E25
+   .long   0x0E1E
+   .long   0x0E17
+   .long   0x0E10
+   .long   0x0E09
+   .long   0x0E02
+   .long   0x0DFB
+   .long   0x0DF4
+   .long   0x0DED
+   .long   0x0DE6
+   .long   0x0DDF
+   .long   0x0DD8
+   .long   0x0DD1
+   .long   0x0DCA
+   .long   0x0DC3
+   .long   0x0DBC
+   .long   0x0DB5
+   .long   0x0DAE
+   .long   0x0DA7
+   .long   0x0DA0
+   .long   0x0D9A
+   .long   0x0D93
+   .long   0x0D8C
+   .long   0x0D85
+   .long   0x0D7E
+   .long   0x0D77
+   .long   0x0D71
+   .long   0x0D6A
+   .long   0x0D63
+   .long   0x0D5C
+   .long   0x0D56
+   .long   0x0D4F
+   .long   0x0D48
+   .long   0x0D42
+   .long   0x0D3B
+   .long   0x0D34
+   .long   0x0D2E
+   .long   0x0D27
+   .long   0x0D20
+   .long   0x0D1A
+   .long   0x0D13
+   .long   0x0D0C
+   .long   0x0D06
+   .long   0x0CFF
+   .long   0x0CF9
+   .long   0x0CF2
+   .long   0x0CEC
+   .long   0x0CE5
+   .long   0x0CDF
+   .long   0x0CD8
+   .long   0x0CD2
+   .long   0x0CCB
+   .long   0x0CC5
+   .long   0x0CBE
+   .long   0x0CB8
+   .long   0x0CB1
+   .long   0x0CAB
+   .long   0x0CA4
+   .long   0x0C9E
+   .long   0x0C98
+   .long   0x0C91
+   .long   0x0C8B
+   .long   0x0C85
+   .long   0x0C7E
+   .long   0x0C78
+   .long   0x0C72
+   .long   0x0C6B
+   .long   0x0C65
+   .long   0x0C5F
+   .long   0x0C58
+   .long   0x0C52
+   .long   0x0C4C
+   .long   0x0C46
+   .long   0x0C3F
+   .long   0x0C39
+   .long   0x0C33
+   .long   0x0C2D
+   .long   0x0C26
+   .long   0x0C20
+   .long   0x0C1A
+   .long   0x0C14
+   .long   0x0C0E
+   .long   0x0C08
+   .long   0x0C02
+   .long   0x0BFB
+   .long   0x0BF5
+   .long   0x0BEF
+   .long   0x0BE9
+   .long   0x0BE3
+   .long   0x0BDD
+   .long   0x0BD7
+   .long   0x0BD1
+   .long   0x0BCB
+   .long   0x0BC5
+   .long   0x0BBF
+   .long   0x0BB9
+   .long   0x0BB3
+   .long   0x0BAD
+   .long   0x0BA7
+   .long   0x0BA1
+   .long   0x0B9B
+   .long   0x0B95
+   .long   0x0B8F
+   .long   0x0B89
+   .long   0x0B83
+   .long   0x0B7D
+   .long   0x0B77
+   .long   0x0B71
+   .long   0x0B6C
+   .long   0x0B66
+   .long   0x0B60
+   .long   0x0B5A
+   .long   0x0B54
+   .long   0x0B4E
+   .long   0x0B48
+   .long   0x0B43
+   .long   0x0B3D
+   .long   0x0B37
+   .long   0x0B31
+   .long   0x0B2B
+   .long   0x0B26
+   .long   0x0B20
+   .long   0x0B1A
+   .long   0x0B14
+   .long   0x0B0F
+   .long   0x0B09
+   .long   0x0B03
+   .long   0x0AFE
+   .long   0x0AF8
+   .long   0x0AF2
+   .long   0x0AED
+   .long   0x0AE7
+   .long   0x0AE1
+   .long   0x0ADC
+   .long   0x0AD6
+   .long   0x0AD0
+   .long   0x0ACB
+   .long   0x0AC5
+   .long   0x0AC0
+   .long   0x0ABA
+   .long   0x0AB4
+   .long   0x0AAF
+   .long   0x0AA9
+   .long   0x0AA4
+   .long   0x0A9E
+   .long   0x0A99
+   .long   0x0A93
+   .long   0x0A8E
+   .long   0x0A88
+   .long   0x0A83
+   .long   0x0A7D
+   .long   0x0A78
+   .long   0x0A72
+   .long   0x0A6D
+   .long   0x0A67
+   .long   0x0A62
+   .long   0x0A5C
+   .long   0x0A57
+   .long   0x0A52
+   .long   0x0A4C
+   .long   0x0A47
+   .long   0x0A41
+   .long   0x0A3C
+   .long   0x0A37
+   .long   0x0A31
+   .long   0x0A2C
+   .long   0x0A27
+   .long   0x0A21
+   .long   0x0A1C
+   .long   0x0A17
+   .long   0x0A11
+   .long   0x0A0C
+   .long   0x0A07
+   .long   0x0A01
+   .long   0x09FC
+   .long   0x09F7
+   .long   0x09F2
+   .long   0x09EC
+   .long   0x09E7
+   .long   0x09E2
+   .long   0x09DD
+   .long   0x09D7
+   .long   0x09D2
+   .long   0x09CD
+   .long   0x09C8
+   .long   0x09C3
+   .long   0x09BD
+   .long   0x09B8
+   .long   0x09B3
+   .long   0x09AE
+   .long   0x09A9
+   .long   0x09A4
+   .long   0x099E
+   .long   0x0999
+   .long   0x0994
+   .long   0x098F
+   .long   0x098A
+   .long   0x0985
+   .long   0x0980
+   .long   0x097B
+   .long   0x0976
+   .long   0x0971
+   .long   0x096C
+   .long   0x0967
+   .long   0x0962
+   .long   0x095C
+   .long   0x0957
+   .long   0x0952
+   .long   0x094D
+   .long   0x0948
+   .long   0x0943
+   .long   0x093E
+   .long   0x0939
+   .long   0x0935
+   .long   0x0930
+   .long   0x092B
+   .long   0x0926
+   .long   0x0921
+   .long   0x091C
+   .long   0x0917
+   .long   0x0912
+   .long   0x090D
+   .long   0x0908
+   .long   0x0903
+   .long   0x08FE
+   .long   0x08FA
+   .long   0x08F5
+   .long   0x08F0
+   .long   0x08EB
+   .long   0x08E6
+   .long   0x08E1
+   .long   0x08DC
+   .long   0x08D8
+   .long   0x08D3
+   .long   0x08CE
+   .long   0x08C9
+   .long   0x08C4
+   .long   0x08C0
+   .long   0x08BB
+   .long   0x08B6
+   .long   0x08B1
+   .long   0x08AC
+   .long   0x08A8
+   .long   0x08A3
+   .long   0x089E
+   .long   0x089A
+   .long   0x0895
+   .long   0x0890
+   .long   0x088B
+   .long   0x0887
+   .long   0x0882
+   .long   0x087D
+   .long   0x0879
+   .long   0x0874
+   .long   0x086F
+   .long   0x086B
+   .long   0x0866
+   .long   0x0861
+   .long   0x085D
+   .long   0x0858
+   .long   0x0853
+   .long   0x084F
+   .long   0x084A
+   .long   0x0846
+   .long   0x0841
+   .long   0x083C
+   .long   0x0838
+   .long   0x0833
+   .long   0x082F
+   .long   0x082A
+   .long   0x0825
+   .long   0x0821
+   .long   0x081C
+   .long   0x0818
+   .long   0x0813
+   .long   0x080F
+   .long   0x080A
+   .long   0x0806
+   .long   0x0801
+   .long   0x07FD
+   .long   0x07F8
+   .long   0x07F4
+   .long   0x07EF
+   .long   0x07EB
+   .long   0x07E6
+   .long   0x07E2
+   .long   0x07DD
+   .long   0x07D9
+   .long   0x07D5
+   .long   0x07D0
+   .long   0x07CC
+   .long   0x07C7
+   .long   0x07C3
+   .long   0x07BE
+   .long   0x07BA
+   .long   0x07B6
+   .long   0x07B1
+   .long   0x07AD
+   .long   0x07A9
+   .long   0x07A4
+   .long   0x07A0
+   .long   0x079B
+   .long   0x0797
+   .long   0x0793
+   .long   0x078E
+   .long   0x078A
+   .long   0x0786
+   .long   0x0781
+   .long   0x077D
+   .long   0x0779
+   .long   0x0774
+   .long   0x0770
+   .long   0x076C
+   .long   0x0768
+   .long   0x0763
+   .long   0x075F
+   .long   0x075B
+   .long   0x0757
+   .long   0x0752
+   .long   0x074E
+   .long   0x074A
+   .long   0x0746
+   .long   0x0741
+   .long   0x073D
+   .long   0x0739
+   .long   0x0735
+   .long   0x0730
+   .long   0x072C
+   .long   0x0728
+   .long   0x0724
+   .long   0x0720
+   .long   0x071C
+   .long   0x0717
+   .long   0x0713
+   .long   0x070F
+   .long   0x070B
+   .long   0x0707
+   .long   0x0703
+   .long   0x06FE
+   .long   0x06FA
+   .long   0x06F6
+   .long   0x06F2
+   .long   0x06EE
+   .long   0x06EA
+   .long   0x06E6
+   .long   0x06E2
+   .long   0x06DE
+   .long   0x06DA
+   .long   0x06D5
+   .long   0x06D1
+   .long   0x06CD
+   .long   0x06C9
+   .long   0x06C5
+   .long   0x06C1
+   .long   0x06BD
+   .long   0x06B9
+   .long   0x06B5
+   .long   0x06B1
+   .long   0x06AD
+   .long   0x06A9
+   .long   0x06A5
+   .long   0x06A1
+   .long   0x069D
+   .long   0x0699
+   .long   0x0695
+   .long   0x0691
+   .long   0x068D
+   .long   0x0689
+   .long   0x0685
+   .long   0x0681
+   .long   0x067D
+   .long   0x0679
+   .long   0x0675
+   .long   0x0671
+   .long   0x066D
+   .long   0x066A
+   .long   0x0666
+   .long   0x0662
+   .long   0x065E
+   .long   0x065A
+   .long   0x0656
+   .long   0x0652
+   .long   0x064E
+   .long   0x064A
+   .long   0x0646
+   .long   0x0643
+   .long   0x063F
+   .long   0x063B
+   .long   0x0637
+   .long   0x0633
+   .long   0x062F
+   .long   0x062B
+   .long   0x0628
+   .long   0x0624
+   .long   0x0620
+   .long   0x061C
+   .long   0x0618
+   .long   0x0614
+   .long   0x0611
+   .long   0x060D
+   .long   0x0609
+   .long   0x0605
+   .long   0x0601
+   .long   0x05FE
+   .long   0x05FA
+   .long   0x05F6
+   .long   0x05F2
+   .long   0x05EF
+   .long   0x05EB
+   .long   0x05E7
+   .long   0x05E3
+   .long   0x05E0
+   .long   0x05DC
+   .long   0x05D8
+   .long   0x05D4
+   .long   0x05D1
+   .long   0x05CD
+   .long   0x05C9
+   .long   0x05C6
+   .long   0x05C2
+   .long   0x05BE
+   .long   0x05BA
+   .long   0x05B7
+   .long   0x05B3
+   .long   0x05AF
+   .long   0x05AC
+   .long   0x05A8
+   .long   0x05A4
+   .long   0x05A1
+   .long   0x059D
+   .long   0x0599
+   .long   0x0596
+   .long   0x0592
+   .long   0x058F
+   .long   0x058B
+   .long   0x0587
+   .long   0x0584
+   .long   0x0580
+   .long   0x057C
+   .long   0x0579
+   .long   0x0575
+   .long   0x0572
+   .long   0x056E
+   .long   0x056B
+   .long   0x0567
+   .long   0x0563
+   .long   0x0560
+   .long   0x055C
+   .long   0x0559
+   .long   0x0555
+   .long   0x0552
+   .long   0x054E
+   .long   0x054A
+   .long   0x0547
+   .long   0x0543
+   .long   0x0540
+   .long   0x053C
+   .long   0x0539
+   .long   0x0535
+   .long   0x0532
+   .long   0x052E
+   .long   0x052B
+   .long   0x0527
+   .long   0x0524
+   .long   0x0520
+   .long   0x051D
+   .long   0x0519
+   .long   0x0516
+   .long   0x0512
+   .long   0x050F
+   .long   0x050B
+   .long   0x0508
+   .long   0x0505
+   .long   0x0501
+   .long   0x04FE
+   .long   0x04FA
+   .long   0x04F7
+   .long   0x04F3
+   .long   0x04F0
+   .long   0x04EC
+   .long   0x04E9
+   .long   0x04E6
+   .long   0x04E2
+   .long   0x04DF
+   .long   0x04DB
+   .long   0x04D8
+   .long   0x04D5
+   .long   0x04D1
+   .long   0x04CE
+   .long   0x04CA
+   .long   0x04C7
+   .long   0x04C4
+   .long   0x04C0
+   .long   0x04BD
+   .long   0x04BA
+   .long   0x04B6
+   .long   0x04B3
+   .long   0x04B0
+   .long   0x04AC
+   .long   0x04A9
+   .long   0x04A6
+   .long   0x04A2
+   .long   0x049F
+   .long   0x049C
+   .long   0x0498
+   .long   0x0495
+   .long   0x0492
+   .long   0x048E
+   .long   0x048B
+   .long   0x0488
+   .long   0x0484
+   .long   0x0481
+   .long   0x047E
+   .long   0x047B
+   .long   0x0477
+   .long   0x0474
+   .long   0x0471
+   .long   0x046E
+   .long   0x046A
+   .long   0x0467
+   .long   0x0464
+   .long   0x0461
+   .long   0x045D
+   .long   0x045A
+   .long   0x0457
+   .long   0x0454
+   .long   0x0450
+   .long   0x044D
+   .long   0x044A
+   .long   0x0447
+   .long   0x0444
+   .long   0x0440
+   .long   0x043D
+   .long   0x043A
+   .long   0x0437
+   .long   0x0434
+   .long   0x0430
+   .long   0x042D
+   .long   0x042A
+   .long   0x0427
+   .long   0x0424
+   .long   0x0420
+   .long   0x041D
+   .long   0x041A
+   .long   0x0417
+   .long   0x0414
+   .long   0x0411
+   .long   0x040E
+   .long   0x040A
+   .long   0x0407
+   .long   0x0404
+   .long   0x0401
+   .long   0x03FE
+   .long   0x03FB
+   .long   0x03F8
+   .long   0x03F5
+   .long   0x03F1
+   .long   0x03EE
+   .long   0x03EB
+   .long   0x03E8
+   .long   0x03E5
+   .long   0x03E2
+   .long   0x03DF
+   .long   0x03DC
+   .long   0x03D9
+   .long   0x03D6
+   .long   0x03D3
+   .long   0x03CF
+   .long   0x03CC
+   .long   0x03C9
+   .long   0x03C6
+   .long   0x03C3
+   .long   0x03C0
+   .long   0x03BD
+   .long   0x03BA
+   .long   0x03B7
+   .long   0x03B4
+   .long   0x03B1
+   .long   0x03AE
+   .long   0x03AB
+   .long   0x03A8
+   .long   0x03A5
+   .long   0x03A2
+   .long   0x039F
+   .long   0x039C
+   .long   0x0399
+   .long   0x0396
+   .long   0x0393
+   .long   0x0390
+   .long   0x038D
+   .long   0x038A
+   .long   0x0387
+   .long   0x0384
+   .long   0x0381
+   .long   0x037E
+   .long   0x037B
+   .long   0x0378
+   .long   0x0375
+   .long   0x0372
+   .long   0x036F
+   .long   0x036C
+   .long   0x0369
+   .long   0x0366
+   .long   0x0363
+   .long   0x0360
+   .long   0x035E
+   .long   0x035B
+   .long   0x0358
+   .long   0x0355
+   .long   0x0352
+   .long   0x034F
+   .long   0x034C
+   .long   0x0349
+   .long   0x0346
+   .long   0x0343
+   .long   0x0340
+   .long   0x033E
+   .long   0x033B
+   .long   0x0338
+   .long   0x0335
+   .long   0x0332
+   .long   0x032F
+   .long   0x032C
+   .long   0x0329
+   .long   0x0327
+   .long   0x0324
+   .long   0x0321
+   .long   0x031E
+   .long   0x031B
+   .long   0x0318
+   .long   0x0315
+   .long   0x0313
+   .long   0x0310
+   .long   0x030D
+   .long   0x030A
+   .long   0x0307
+   .long   0x0304
+   .long   0x0302
+   .long   0x02FF
+   .long   0x02FC
+   .long   0x02F9
+   .long   0x02F6
+   .long   0x02F3
+   .long   0x02F1
+   .long   0x02EE
+   .long   0x02EB
+   .long   0x02E8
+   .long   0x02E5
+   .long   0x02E3
+   .long   0x02E0
+   .long   0x02DD
+   .long   0x02DA
+   .long   0x02D8
+   .long   0x02D5
+   .long   0x02D2
+   .long   0x02CF
+   .long   0x02CC
+   .long   0x02CA
+   .long   0x02C7
+   .long   0x02C4
+   .long   0x02C1
+   .long   0x02BF
+   .long   0x02BC
+   .long   0x02B9
+   .long   0x02B7
+   .long   0x02B4
+   .long   0x02B1
+   .long   0x02AE
+   .long   0x02AC
+   .long   0x02A9
+   .long   0x02A6
+   .long   0x02A3
+   .long   0x02A1
+   .long   0x029E
+   .long   0x029B
+   .long   0x0299
+   .long   0x0296
+   .long   0x0293
+   .long   0x0291
+   .long   0x028E
+   .long   0x028B
+   .long   0x0288
+   .long   0x0286
+   .long   0x0283
+   .long   0x0280
+   .long   0x027E
+   .long   0x027B
+   .long   0x0278
+   .long   0x0276
+   .long   0x0273
+   .long   0x0270
+   .long   0x026E
+   .long   0x026B
+   .long   0x0268
+   .long   0x0266
+   .long   0x0263
+   .long   0x0261
+   .long   0x025E
+   .long   0x025B
+   .long   0x0259
+   .long   0x0256
+   .long   0x0253
+   .long   0x0251
+   .long   0x024E
+   .long   0x024C
+   .long   0x0249
+   .long   0x0246
+   .long   0x0244
+   .long   0x0241
+   .long   0x023E
+   .long   0x023C
+   .long   0x0239
+   .long   0x0237
+   .long   0x0234
+   .long   0x0232
+   .long   0x022F
+   .long   0x022C
+   .long   0x022A
+   .long   0x0227
+   .long   0x0225
+   .long   0x0222
+   .long   0x021F
+   .long   0x021D
+   .long   0x021A
+   .long   0x0218
+   .long   0x0215
+   .long   0x0213
+   .long   0x0210
+   .long   0x020E
+   .long   0x020B
+   .long   0x0208
+   .long   0x0206
+   .long   0x0203
+   .long   0x0201
+   .long   0x01FE
+   .long   0x01FC
+   .long   0x01F9
+   .long   0x01F7
+   .long   0x01F4
+   .long   0x01F2
+   .long   0x01EF
+   .long   0x01ED
+   .long   0x01EA
+   .long   0x01E8
+   .long   0x01E5
+   .long   0x01E3
+   .long   0x01E0
+   .long   0x01DE
+   .long   0x01DB
+   .long   0x01D9
+   .long   0x01D6
+   .long   0x01D4
+   .long   0x01D1
+   .long   0x01CF
+   .long   0x01CC
+   .long   0x01CA
+   .long   0x01C7
+   .long   0x01C5
+   .long   0x01C2
+   .long   0x01C0
+   .long   0x01BD
+   .long   0x01BB
+   .long   0x01B9
+   .long   0x01B6
+   .long   0x01B4
+   .long   0x01B1
+   .long   0x01AF
+   .long   0x01AC
+   .long   0x01AA
+   .long   0x01A7
+   .long   0x01A5
+   .long   0x01A3
+   .long   0x01A0
+   .long   0x019E
+   .long   0x019B
+   .long   0x0199
+   .long   0x0196
+   .long   0x0194
+   .long   0x0192
+   .long   0x018F
+   .long   0x018D
+   .long   0x018A
+   .long   0x0188
+   .long   0x0186
+   .long   0x0183
+   .long   0x0181
+   .long   0x017E
+   .long   0x017C
+   .long   0x017A
+   .long   0x0177
+   .long   0x0175
+   .long   0x0173
+   .long   0x0170
+   .long   0x016E
+   .long   0x016B
+   .long   0x0169
+   .long   0x0167
+   .long   0x0164
+   .long   0x0162
+   .long   0x0160
+   .long   0x015D
+   .long   0x015B
+   .long   0x0159
+   .long   0x0156
+   .long   0x0154
+   .long   0x0151
+   .long   0x014F
+   .long   0x014D
+   .long   0x014A
+   .long   0x0148
+   .long   0x0146
+   .long   0x0143
+   .long   0x0141
+   .long   0x013F
+   .long   0x013C
+   .long   0x013A
+   .long   0x0138
+   .long   0x0136
+   .long   0x0133
+   .long   0x0131
+   .long   0x012F
+   .long   0x012C
+   .long   0x012A
+   .long   0x0128
+   .long   0x0125
+   .long   0x0123
+   .long   0x0121
+   .long   0x011F
+   .long   0x011C
+   .long   0x011A
+   .long   0x0118
+   .long   0x0115
+   .long   0x0113
+   .long   0x0111
+   .long   0x010F
+   .long   0x010C
+   .long   0x010A
+   .long   0x0108
+   .long   0x0105
+   .long   0x0103
+   .long   0x0101
+   .long   0x00FF
+   .long   0x00FC
+   .long   0x00FA
+   .long   0x00F8
+   .long   0x00F6
+   .long   0x00F3
+   .long   0x00F1
+   .long   0x00EF
+   .long   0x00ED
+   .long   0x00EA
+   .long   0x00E8
+   .long   0x00E6
+   .long   0x00E4
+   .long   0x00E2
+   .long   0x00DF
+   .long   0x00DD
+   .long   0x00DB
+   .long   0x00D9
+   .long   0x00D6
+   .long   0x00D4
+   .long   0x00D2
+   .long   0x00D0
+   .long   0x00CE
+   .long   0x00CB
+   .long   0x00C9
+   .long   0x00C7
+   .long   0x00C5
+   .long   0x00C3
+   .long   0x00C0
+   .long   0x00BE
+   .long   0x00BC
+   .long   0x00BA
+   .long   0x00B8
+   .long   0x00B5
+   .long   0x00B3
+   .long   0x00B1
+   .long   0x00AF
+   .long   0x00AD
+   .long   0x00AB
+   .long   0x00A8
+   .long   0x00A6
+   .long   0x00A4
+   .long   0x00A2
+   .long   0x00A0
+   .long   0x009E
+   .long   0x009B
+   .long   0x0099
+   .long   0x0097
+   .long   0x0095
+   .long   0x0093
+   .long   0x0091
+   .long   0x008F
+   .long   0x008C
+   .long   0x008A
+   .long   0x0088
+   .long   0x0086
+   .long   0x0084
+   .long   0x0082
+   .long   0x0080
+   .long   0x007D
+   .long   0x007B
+   .long   0x0079
+   .long   0x0077
+   .long   0x0075
+   .long   0x0073
+   .long   0x0071
+   .long   0x006F
+   .long   0x006D
+   .long   0x006A
+   .long   0x0068
+   .long   0x0066
+   .long   0x0064
+   .long   0x0062
+   .long   0x0060
+   .long   0x005E
+   .long   0x005C
+   .long   0x005A
+   .long   0x0058
+   .long   0x0056
+   .long   0x0053
+   .long   0x0051
+   .long   0x004F
+   .long   0x004D
+   .long   0x004B
+   .long   0x0049
+   .long   0x0047
+   .long   0x0045
+   .long   0x0043
+   .long   0x0041
+   .long   0x003F
+   .long   0x003D
+   .long   0x003B
+   .long   0x0039
+   .long   0x0036
+   .long   0x0034
+   .long   0x0032
+   .long   0x0030
+   .long   0x002E
+   .long   0x002C
+   .long   0x002A
+   .long   0x0028
+   .long   0x0026
+   .long   0x0024
+   .long   0x0022
+   .long   0x0020
+   .long   0x001E
+   .long   0x001C
+   .long   0x001A
+   .long   0x0018
+   .long   0x0016
+   .long   0x0014
+   .long   0x0012
+   .long   0x0010
+   .long   0x000E
+   .long   0x000C
+   .long   0x000A
+   .long   0x0008
+   .long   0x0006
+   .long   0x0004
+   .long   0x0002
+
diff --git a/src/gas/vrd4log.S b/src/gas/vrd4log.S
new file mode 100644
index 0000000..1e2b1e4
--- /dev/null
+++ b/src/gas/vrd4log.S
@@ -0,0 +1,855 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrd4log.asm
+#
+# A vector implementation of the log libm function.
+#
+# Prototype:
+#
+#    __m128d,__m128d __vrd4_log(__m128d x1, __m128d x2);
+#
+#   Computes the natural log of x.
+#   Returns proper C99 values, but may not raise status flags properly.
+#   Less than 1 ulp of error.  This version can compute 4 logs in
+#   192 cycles, or 48 per value
+#
+# This routine computes 4 double precision log values at a time.
+# The four values are passed as packed doubles in xmm0 and xmm1.
+# The four results are returned as packed doubles in xmm0 and xmm1.
+# Note that this represents a non-standard ABI usage, as no ABI
+# ( and indeed C) currently allows returning 2 values for a function.
+# It is expected that some compilers may be able to take advantage of this
+# interface when implementing vectorized loops.  Using the array implementation
+# of the routine requires putting the inputs into memory, and retrieving
+# the results from memory.  This routine eliminates the need for this
+# overhead if the data does not already reside in memory.
+# This routine is derived directly from the array version.
+#
+
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+# define local variable storage offsets
+.equ	p_x,0			# temporary for error checking operation
+.equ	p_idx,0x010		# index storage
+.equ	p_xexp,0x020		# index storage
+
+.equ	p_x2,0x030		# temporary for error checking operation
+.equ	p_idx2,0x040		# index storage
+.equ	p_xexp2,0x050		# index storage
+
+.equ	save_xa,0x060		#qword
+.equ	save_ya,0x068		#qword
+.equ	save_nv,0x070		#qword
+.equ	p_iter,0x078		# qword	storage for number of loop iterations
+
+.equ	save_rbx,0x080		#qword
+
+
+.equ	p2_temp,0x090		# second temporary for get/put bits operation
+.equ	p2_temp1,0x0b0		# second temporary for exponent multiply
+
+.equ	p_n1,0x0c0		# temporary for near one check
+.equ	p_n12,0x0d0		# temporary for near one check
+
+
+.equ	stack_size,0x0e8
+
+
+# parameters are expected as:
+# xmm0 - __m128d x1
+# xmm1 - __m128d x2
+
+    .text
+    .align 16
+    .p2align 4,,15
+.globl __vrd4_log
+    .type   __vrd4_log,@function
+__vrd4_log:
+	sub		$stack_size,%rsp
+	mov		%rbx,save_rbx(%rsp)	# save rdi
+
+# process 4 values at a time.
+
+		movdqa	%xmm1,p_x2(%rsp)	# save the input values
+	movdqa	%xmm0,p_x(%rsp)	# save the input values
+# compute the logs
+
+##  if NaN or inf
+
+#      /* Store the exponent of x in xexp and put
+#         f into the range [0.5,1) */
+
+	pxor	%xmm1,%xmm1
+	movdqa	%xmm0,%xmm3
+	psrlq	$52,%xmm3
+	psubq	.L__mask_1023(%rip),%xmm3
+	packssdw	%xmm1,%xmm3
+	cvtdq2pd	%xmm3,%xmm6			# xexp
+	movdqa	%xmm0,%xmm2
+	subpd	.L__real_one(%rip),%xmm2
+
+	movapd	%xmm6,p_xexp(%rsp)
+	andpd	.L__real_notsign(%rip),%xmm2
+	xor		%rax,%rax
+
+	movdqa	%xmm0,%xmm3
+	pand	.L__real_mant(%rip),%xmm3
+
+	cmppd	$1,.L__real_threshold(%rip),%xmm2
+	movmskpd	%xmm2,%ecx
+	movdqa	%xmm3,%xmm4
+	mov			%ecx,p_n1(%rsp)
+
+#/* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+	psrlq	$45,%xmm3
+	movdqa	%xmm3,%xmm2
+	psrlq	$1,%xmm3
+	paddq	.L__mask_040(%rip),%xmm3
+	pand	.L__mask_001(%rip),%xmm2
+	paddq	%xmm2,%xmm3
+
+	packssdw	%xmm1,%xmm3
+	cvtdq2pd	%xmm3,%xmm1
+		pxor	%xmm7,%xmm7
+		movdqa	p_x2(%rsp),%xmm2
+		movapd	p_x2(%rsp),%xmm5
+		psrlq	$52,%xmm2
+		psubq	.L__mask_1023(%rip),%xmm2
+		packssdw	%xmm7,%xmm2
+		subpd	.L__real_one(%rip),%xmm5
+		andpd	.L__real_notsign(%rip),%xmm5
+		cvtdq2pd	%xmm2,%xmm6			# xexp
+	xor		%rcx,%rcx
+		cmppd	$1,.L__real_threshold(%rip),%xmm5
+	movq	 %xmm3,p_idx(%rsp)
+
+# reduce and get u
+	por		.L__real_half(%rip),%xmm4
+	movdqa	%xmm4,%xmm2
+		movapd	%xmm6,p_xexp2(%rsp)
+
+	# do near one check
+		movmskpd	%xmm5,%edx
+		mov			%edx,p_n12(%rsp)
+
+	mulpd	.L__real_3f80000000000000(%rip),%xmm1				# f1 = index/128
+
+
+	lea		.L__np_ln_lead_table(%rip),%rdx
+	mov		p_idx(%rsp),%eax
+		movdqa	p_x2(%rsp),%xmm6
+
+	movapd	.L__real_half(%rip),%xmm5							# .5
+	subpd	%xmm1,%xmm2											# f2 = f - f1
+		pand	.L__real_mant(%rip),%xmm6
+	mulpd	%xmm2,%xmm5
+	addpd	%xmm5,%xmm1
+
+		movdqa	%xmm6,%xmm8
+		psrlq	$45,%xmm6
+		movdqa	%xmm6,%xmm4
+
+		psrlq	$1,%xmm6
+		paddq	.L__mask_040(%rip),%xmm6
+		pand	.L__mask_001(%rip),%xmm4
+		paddq	%xmm4,%xmm6
+# do error checking here for scheduling.  Saves a bunch of cycles as
+# compared to doing this at the start of the routine.
+##  if NaN or inf
+	movapd	%xmm0,%xmm3
+	andpd	.L__real_inf(%rip),%xmm3
+	cmppd	$0,.L__real_inf(%rip),%xmm3
+	movmskpd	%xmm3,%r8d
+		packssdw	%xmm7,%xmm6
+		por		.L__real_half(%rip),%xmm8
+		movq	 %xmm6,p_idx2(%rsp)
+		cvtdq2pd	%xmm6,%xmm9
+
+	cmppd	$2,.L__real_zero(%rip),%xmm0
+		mulpd	.L__real_3f80000000000000(%rip),%xmm9				# f1 = index/128
+	movmskpd	%xmm0,%r9d
+# delaying this divide helps, but moving the other one does not.
+# it was after the paddq
+	divpd	%xmm1,%xmm2				# u
+
+# compute the index into the log tables
+#
+
+        movlpd   -512(%rdx,%rax,8),%xmm0                # z1
+        mov             p_idx+4(%rsp),%ecx
+        movhpd   -512(%rdx,%rcx,8),%xmm0                # z1
+# solve for ln(1+u)
+	movapd	%xmm2,%xmm1				# u
+	mulpd	%xmm2,%xmm2				# u^2
+	movapd	%xmm2,%xmm5
+	movapd	.L__real_cb3(%rip),%xmm3
+	mulpd	%xmm2,%xmm3				#Cu2
+	mulpd	%xmm1,%xmm5				# u^3
+	addpd	.L__real_cb2(%rip),%xmm3 #B+Cu2
+
+	mulpd	%xmm5,%xmm2				# u^5
+	movapd	.L__real_log2_lead(%rip),%xmm4
+
+	mulpd	.L__real_cb1(%rip),%xmm5 #Au3
+	addpd	%xmm5,%xmm1				# u+Au3
+	mulpd	%xmm3,%xmm2				# u5(B+Cu2)
+
+	movapd	p_xexp(%rsp),%xmm5		# xexp
+	addpd	%xmm2,%xmm1				# poly
+# recombine
+	mulpd	%xmm5,%xmm4				# xexp * log2_lead
+	addpd	%xmm4,%xmm0				#r1
+	lea		.L__np_ln_tail_table(%rip),%rdx
+        movlpd   -512(%rdx,%rax,8),%xmm4                #z2     +=q
+        movhpd   -512(%rdx,%rcx,8),%xmm4                #z2     +=q
+		lea		.L__np_ln_lead_table(%rip),%rdx
+		mov		p_idx2(%rsp),%eax
+		mov		p_idx2+4(%rsp),%ecx
+	addpd	%xmm4,%xmm1
+
+	mulpd	.L__real_log2_tail(%rip),%xmm5
+
+		movapd	.L__real_half(%rip),%xmm4							# .5
+		subpd	%xmm9,%xmm8											# f2 = f - f1
+		mulpd	%xmm8,%xmm4
+		addpd	%xmm4,%xmm9
+
+	addpd	%xmm5,%xmm1				#r2
+		divpd	%xmm9,%xmm8				# u
+		movapd	p_x2(%rsp),%xmm3
+		andpd	.L__real_inf(%rip),%xmm3
+		cmppd	$0,.L__real_inf(%rip),%xmm3
+		movmskpd	%xmm3,%r10d
+		movapd	p_x2(%rsp),%xmm6
+		cmppd	$2,.L__real_zero(%rip),%xmm6
+		movmskpd	%xmm6,%r11d
+
+# check for nans/infs
+	test		$3,%r8d
+	addpd	%xmm1,%xmm0
+	jnz		.L__log_naninf
+.L__vlog1:
+# check for negative numbers or zero
+	test		$3,%r9d
+	jnz		.L__z_or_n
+
+
+.L__vlog2:
+
+
+	# It seems like a good idea to try and interleave
+	# even more of the following code sooner into the
+	# program.  But there were conflicts with the table
+	# index registers, making the problem difficult.
+	# After a lot of work in a branch of this file,
+	# I was not able to match the speed of this version.
+	# CodeAnalyst shows that there is lots of unused add
+	# pipe time around the divides, but the processor
+	# doesn't seem to be able to schedule in those slots.
+
+	        movlpd   -512(%rdx,%rax,8),%xmm7                #z2     +=q
+        	movhpd   -512(%rdx,%rcx,8),%xmm7                #z2     +=q
+
+# check for near one
+	mov			p_n1(%rsp),%r9d
+	test			$3,%r9d
+	jnz			.L__near_one1
+.L__vlog2n:
+
+
+	# solve for ln(1+u)
+		movapd	%xmm8,%xmm9				# u
+		mulpd	%xmm8,%xmm8				# u^2
+		movapd	%xmm8,%xmm5
+		movapd	.L__real_cb3(%rip),%xmm3
+		mulpd	%xmm8,%xmm3				#Cu2
+		mulpd	%xmm9,%xmm5				# u^3
+		addpd	.L__real_cb2(%rip),%xmm3 		#B+Cu2
+
+		mulpd	%xmm5,%xmm8				# u^5
+		movapd	.L__real_log2_lead(%rip),%xmm4
+
+		mulpd	.L__real_cb1(%rip),%xmm5 		#Au3
+		addpd	%xmm5,%xmm9				# u+Au3
+		mulpd	%xmm3,%xmm8				# u5(B+Cu2)
+
+		movapd	p_xexp2(%rsp),%xmm5			# xexp
+		addpd	%xmm8,%xmm9				# poly
+	# recombine
+		mulpd	%xmm5,%xmm4
+		addpd	%xmm4,%xmm7				#r1
+		lea		.L__np_ln_tail_table(%rip),%rdx
+	        movlpd   -512(%rdx,%rax,8),%xmm2                #z2     +=q
+        	movhpd   -512(%rdx,%rcx,8),%xmm2                #z2     +=q
+		addpd	%xmm2,%xmm9
+
+		mulpd	.L__real_log2_tail(%rip),%xmm5
+
+		addpd	%xmm5,%xmm9				#r2
+
+	# check for nans/infs
+		test		$3,%r10d
+		addpd	%xmm9,%xmm7
+		jnz		.L__log_naninf2
+.L__vlog3:
+# check for negative numbers or zero
+		test		$3,%r11d
+		jnz		.L__z_or_n2
+
+.L__vlog4:
+
+
+	mov			p_n12(%rsp),%r9d
+	test			$3,%r9d
+	jnz			.L__near_one2
+
+.L__vlog4n:
+
+# store the result _m128d
+		movapd	%xmm7,%xmm1
+
+
+.L__finish:
+	mov		save_rbx(%rsp),%rbx		# restore rbx
+	add		$stack_size,%rsp
+	ret
+
+	.align	16
+.Lboth_nearone:
+# saves 10 cycles
+#      r = x - 1.0;
+	movapd	.L__real_two(%rip),%xmm2
+	subpd	.L__real_one(%rip),%xmm0	   # r
+#      u          = r / (2.0 + r);
+	addpd	%xmm0,%xmm2
+	movapd	%xmm0,%xmm1
+	divpd	%xmm2,%xmm1		# u
+	movapd	.L__real_ca4(%rip),%xmm4	  #D
+	movapd	.L__real_ca3(%rip),%xmm5	  #C
+#      correction = r * u;
+	movapd	%xmm0,%xmm6
+	mulpd	%xmm1,%xmm6		# correction
+#      u          = u + u;
+	addpd	%xmm1,%xmm1		#u
+	movapd	%xmm1,%xmm2
+	mulpd	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulpd	%xmm1,%xmm5		# Cu
+	movapd	%xmm1,%xmm3
+	mulpd	%xmm2,%xmm3		# u^3
+	mulpd	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulpd	%xmm3,%xmm4		#Du^3
+
+	addpd	.L__real_ca1(%rip),%xmm2	# +A
+	movapd	%xmm3,%xmm1
+	mulpd	%xmm1,%xmm1		# u^6
+	addpd	%xmm4,%xmm5		#Cu+Du3
+
+	mulpd	%xmm3,%xmm2		#u3(A+Bu2)
+	mulpd	%xmm5,%xmm1		#u6(Cu+Du3)
+	addpd	%xmm1,%xmm2
+	subpd	%xmm6,%xmm2		# -correction
+
+#      return r + r2;
+	addpd	%xmm2,%xmm0
+	ret
+
+	.align	16
+.L__near_one1:
+	cmp	$3,%r9d
+	jnz		.L__n1nb1
+
+	movapd	p_x(%rsp),%xmm0
+	call	.Lboth_nearone
+	jmp		.L__vlog2n
+
+	.align	16
+.L__n1nb1:
+	test	$1,%r9d
+	jz		.L__lnn12
+
+	movlpd	p_x(%rsp),%xmm0
+	call	.L__ln1
+
+.L__lnn12:
+	test	$2,%r9d		# second number?
+	jz		.L__lnn1e
+	movlpd	%xmm0,p_x(%rsp)
+	movlpd	p_x+8(%rsp),%xmm0
+	call	.L__ln1
+	movlpd	%xmm0,p_x+8(%rsp)
+	movapd	p_x(%rsp),%xmm0
+
+.L__lnn1e:
+	jmp		.L__vlog2n
+
+
+	.align	16
+.L__near_one2:
+	cmp	$3,%r9d
+	jnz		.L__n1nb2
+
+	movapd	%xmm0,%xmm8
+	movapd	p_x2(%rsp),%xmm0
+	call	.Lboth_nearone
+	movapd	%xmm0,%xmm7
+	movapd	%xmm8,%xmm0
+	jmp		.L__vlog4n
+
+	.align	16
+.L__n1nb2:
+	movapd	%xmm0,%xmm8
+	test	$1,%r9d
+	jz		.L__lnn22
+
+	movapd	%xmm7,%xmm0
+	movlpd	p_x2(%rsp),%xmm0
+	call	.L__ln1
+	movapd	%xmm0,%xmm7
+
+.L__lnn22:
+	test	$2,%r9d		# second number?
+	jz		.L__lnn2e
+	movlpd	%xmm7,p_x2(%rsp)
+	movlpd	p_x2+8(%rsp),%xmm0
+	call	.L__ln1
+	movlpd	%xmm0,p_x2+8(%rsp)
+	movapd	p_x2(%rsp),%xmm7
+
+.L__lnn2e:
+	movapd	%xmm8,%xmm0
+	jmp		.L__vlog4n
+
+	.align	16
+
+.L__ln1:
+# saves 10 cycles
+#      r = x - 1.0;
+	movlpd	.L__real_two(%rip),%xmm2
+	subsd	.L__real_one(%rip),%xmm0	   # r
+#      u          = r / (2.0 + r);
+	addsd	%xmm0,%xmm2
+	movsd	%xmm0,%xmm1
+	divsd	%xmm2,%xmm1		# u
+	movlpd	.L__real_ca4(%rip),%xmm4	  #D
+	movlpd	.L__real_ca3(%rip),%xmm5	  #C
+#      correction = r * u;
+	movsd	%xmm0,%xmm6
+	mulsd	%xmm1,%xmm6		# correction
+#      u          = u + u;
+	addsd	%xmm1,%xmm1		#u
+	movsd	%xmm1,%xmm2
+	mulsd	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulsd	%xmm1,%xmm5		# Cu
+	movsd	%xmm1,%xmm3
+	mulsd	%xmm2,%xmm3		# u^3
+	mulsd	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulsd	%xmm3,%xmm4		#Du^3
+
+	addsd	.L__real_ca1(%rip),%xmm2	# +A
+	movsd	%xmm3,%xmm1
+	mulsd	%xmm1,%xmm1		# u^6
+	addsd	%xmm4,%xmm5		#Cu+Du3
+
+	mulsd	%xmm3,%xmm2		#u3(A+Bu2)
+	mulsd	%xmm5,%xmm1		#u6(Cu+Du3)
+	addsd	%xmm1,%xmm2
+	subsd	%xmm6,%xmm2		# -correction
+
+#      return r + r2;
+	addsd	%xmm2,%xmm0
+	ret
+
+	.align	16
+
+# at least one of the numbers was a nan or infinity
+.L__log_naninf:
+	test		$1,%r8d		# first number?
+	jz		.L__lninf2
+
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x(%rsp),%rdx
+	movlpd	p_x(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$2,%xmm1,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__lninf2:
+	test		$2,%r8d		# second number?
+	jz		.L__lninfe
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x+8(%rsp),%rdx
+	movlpd	p_x+8(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$0,%xmm0,%xmm1
+	movapd	%xmm1,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__lninfe:
+	jmp		.L__vlog1		# continue processing if not
+
+# at least one of the numbers was a nan or infinity
+.L__log_naninf2:
+	movapd	%xmm0,%xmm2
+	test		$1,%r10d		# first number?
+	jz		.L__lninf22
+
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm7,%xmm1		# save the inputs
+	mov		p_x2(%rsp),%rdx
+	movlpd	p_x2(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$2,%xmm7,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+	movapd	%xmm0,%xmm7
+
+.L__lninf22:
+	test		$2,%r10d		# second number?
+	jz		.L__lninfe2
+
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	mov		p_x2+8(%rsp),%rdx
+	movlpd	p_x2+8(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$0,%xmm0,%xmm7
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__lninfe2:
+	movapd	%xmm2,%xmm0
+	jmp		.L__vlog3		# continue processing if not
+
+# a subroutine to treat one number for nan/infinity
+# the number is expected in rdx and returned in the low
+# half of xmm0
+.L__lni:
+	mov		$0x0000FFFFFFFFFFFFF,%rax
+	test	%rax,%rdx
+	jnz		.L__lnan					# jump if mantissa not zero, so it's a NaN
+# inf
+	rcl		$1,%rdx
+	jnc		.L__lne2					# log(+inf) = inf
+# negative x
+	movlpd	.L__real_nan(%rip),%xmm0
+	ret
+
+#NaN
+.L__lnan:
+	mov		$0x00008000000000000,%rax	# convert to quiet
+	or		%rax,%rdx
+.L__lne:
+	movd	%rdx,%xmm0
+.L__lne2:
+	ret
+
+	.align	16
+
+# at least one of the numbers was a zero, a negative number, or both.
+.L__z_or_n:
+	test		$1,%r9d		# first number?
+	jz		.L__zn2
+
+	mov		%rax,p2_temp(%rsp)
+ 	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x(%rsp),%rax
+	call	.L__zni
+	shufpd	$2,%xmm1,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__zn2:
+	test		$2,%r9d		# second number?
+	jz		.L__zne
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x+8(%rsp),%rax
+	call	.L__zni
+	shufpd	$0,%xmm0,%xmm1
+	movapd	%xmm1,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__zne:
+	jmp		.L__vlog2
+
+.L__z_or_n2:
+	movapd	%xmm0,%xmm2
+	test		$1,%r11d		# first number?
+	jz		.L__zn22
+
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	mov		p_x2(%rsp),%rax
+	call	.L__zni
+	shufpd	$2,%xmm7,%xmm0
+	movapd	%xmm0,%xmm7
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__zn22:
+	test		$2,%r11d		# second number?
+	jz		.L__zne2
+
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	mov		p_x2+8(%rsp),%rax
+	call	.L__zni
+	shufpd	$0,%xmm0,%xmm7
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__zne2:
+	movapd	%xmm2,%xmm0
+	jmp		.L__vlog4
+# a subroutine to treat one number for zero or negative values
+# the number is expected in rax and returned in the low
+# half of xmm0
+.L__zni:
+	shl		$1,%rax
+	jnz		.L__zn_x		 ## if just a carry, then must be negative
+	movlpd	.L__real_ninf(%rip),%xmm0  # C99 specs -inf for +-0
+	ret
+.L__zn_x:
+	movlpd	.L__real_nan(%rip),%xmm0
+	ret
+
+
+
+	.data
+	.align	16
+
+.L__real_one:				.quad 0x03ff0000000000000	# 1.0
+						.quad 0x03ff0000000000000					# for alignment
+.L__real_two:				.quad 0x04000000000000000	# 1.0
+						.quad 0x04000000000000000
+.L__real_ninf:				.quad 0x0fff0000000000000	# -inf
+						.quad 0x0fff0000000000000
+.L__real_inf:				.quad 0x07ff0000000000000	# +inf
+						.quad 0x07ff0000000000000
+.L__real_nan:				.quad 0x07ff8000000000000	# NaN
+						.quad 0x07ff8000000000000
+
+.L__real_zero:				.quad 0x00000000000000000	# 0.0
+						.quad 0x00000000000000000
+
+.L__real_sign:				.quad 0x08000000000000000	# sign bit
+						.quad 0x08000000000000000
+.L__real_notsign:			.quad 0x07ffFFFFFFFFFFFFF	# ^sign bit
+						.quad 0x07ffFFFFFFFFFFFFF
+.L__real_threshold:		.quad 0x03F9EB85000000000	# .03
+						.quad 0x03F9EB85000000000
+.L__real_qnanbit:			.quad 0x00008000000000000	# quiet nan bit
+						.quad 0x00008000000000000
+.L__real_mant:				.quad 0x0000FFFFFFFFFFFFF	# mantissa bits
+						.quad 0x0000FFFFFFFFFFFFF
+.L__real_3f80000000000000:	.quad 0x03f80000000000000	# /* 0.0078125 = 1/128 */
+						.quad 0x03f80000000000000
+.L__mask_1023:				.quad 0x000000000000003ff	#
+						.quad 0x000000000000003ff
+.L__mask_040:				.quad 0x00000000000000040	#
+						.quad 0x00000000000000040
+.L__mask_001:				.quad 0x00000000000000001	#
+						.quad 0x00000000000000001
+
+.L__real_ca1:				.quad 0x03fb55555555554e6	# 8.33333333333317923934e-02
+						.quad 0x03fb55555555554e6
+.L__real_ca2:				.quad 0x03f89999999bac6d4	# 1.25000000037717509602e-02
+						.quad 0x03f89999999bac6d4
+.L__real_ca3:				.quad 0x03f62492307f1519f	# 2.23213998791944806202e-03
+						.quad 0x03f62492307f1519f
+.L__real_ca4:				.quad 0x03f3c8034c85dfff0	# 4.34887777707614552256e-04
+						.quad 0x03f3c8034c85dfff0
+
+
+.L__real_cb1:				.quad 0x03fb5555555555557	# 8.33333333333333593622e-02
+						.quad 0x03fb5555555555557
+.L__real_cb2:				.quad 0x03f89999999865ede	# 1.24999999978138668903e-02
+						.quad 0x03f89999999865ede
+.L__real_cb3:				.quad 0x03f6249423bd94741	# 2.23219810758559851206e-03
+						.quad 0x03f6249423bd94741
+.L__real_log2_lead:  		.quad 0x03fe62e42e0000000	# log2_lead	  6.93147122859954833984e-01
+						.quad 0x03fe62e42e0000000
+.L__real_log2_tail: 		.quad 0x03e6efa39ef35793c	# log2_tail	  5.76999904754328540596e-08
+						.quad 0x03e6efa39ef35793c
+
+.L__real_half:				.quad 0x03fe0000000000000	# 1/2
+						.quad 0x03fe0000000000000
+
+	.align	16
+
+.L__np_ln_lead_table:
+	.quad	0x0000000000000000 		# 0.00000000000000000000e+00
+	.quad	0x3f8fc0a800000000		# 1.55041813850402832031e-02
+	.quad	0x3f9f829800000000		# 3.07716131210327148438e-02
+	.quad	0x3fa7745800000000		# 4.58095073699951171875e-02
+	.quad	0x3faf0a3000000000		# 6.06245994567871093750e-02
+	.quad	0x3fb341d700000000		# 7.52233862876892089844e-02
+	.quad	0x3fb6f0d200000000		# 8.96121263504028320312e-02
+	.quad	0x3fba926d00000000		# 1.03796780109405517578e-01
+	.quad	0x3fbe270700000000		# 1.17783010005950927734e-01
+	.quad	0x3fc0d77e00000000		# 1.31576299667358398438e-01
+	.quad	0x3fc2955280000000		# 1.45181953907012939453e-01
+	.quad	0x3fc44d2b00000000		# 1.58604979515075683594e-01
+	.quad	0x3fc5ff3000000000		# 1.71850204467773437500e-01
+	.quad	0x3fc7ab8900000000		# 1.84922337532043457031e-01
+	.quad	0x3fc9525a80000000		# 1.97825729846954345703e-01
+	.quad	0x3fcaf3c900000000		# 2.10564732551574707031e-01
+	.quad	0x3fcc8ff780000000		# 2.23143517971038818359e-01
+	.quad	0x3fce270700000000		# 2.35566020011901855469e-01
+	.quad	0x3fcfb91800000000		# 2.47836112976074218750e-01
+	.quad	0x3fd0a324c0000000		# 2.59957492351531982422e-01
+	.quad	0x3fd1675c80000000		# 2.71933674812316894531e-01
+	.quad	0x3fd22941c0000000		# 2.83768117427825927734e-01
+	.quad	0x3fd2e8e280000000		# 2.95464158058166503906e-01
+	.quad	0x3fd3a64c40000000		# 3.07025015354156494141e-01
+	.quad	0x3fd4618bc0000000		# 3.18453729152679443359e-01
+	.quad	0x3fd51aad80000000		# 3.29753279685974121094e-01
+	.quad	0x3fd5d1bd80000000		# 3.40926527976989746094e-01
+	.quad	0x3fd686c800000000		# 3.51976394653320312500e-01
+	.quad	0x3fd739d7c0000000		# 3.62905442714691162109e-01
+	.quad	0x3fd7eaf800000000		# 3.73716354370117187500e-01
+	.quad	0x3fd89a3380000000		# 3.84411692619323730469e-01
+	.quad	0x3fd9479400000000		# 3.94993782043457031250e-01
+	.quad	0x3fd9f323c0000000		# 4.05465066432952880859e-01
+	.quad	0x3fda9cec80000000		# 4.15827870368957519531e-01
+	.quad	0x3fdb44f740000000		# 4.26084339618682861328e-01
+	.quad	0x3fdbeb4d80000000		# 4.36236739158630371094e-01
+	.quad	0x3fdc8ff7c0000000		# 4.46287095546722412109e-01
+	.quad	0x3fdd32fe40000000		# 4.56237375736236572266e-01
+	.quad	0x3fddd46a00000000		# 4.66089725494384765625e-01
+	.quad	0x3fde744240000000		# 4.75845873355865478516e-01
+	.quad	0x3fdf128f40000000		# 4.85507786273956298828e-01
+	.quad	0x3fdfaf5880000000		# 4.95077252388000488281e-01
+	.quad	0x3fe02552a0000000		# 5.04556000232696533203e-01
+	.quad	0x3fe0723e40000000		# 5.13945698738098144531e-01
+	.quad	0x3fe0be72e0000000		# 5.23248136043548583984e-01
+	.quad	0x3fe109f380000000		# 5.32464742660522460938e-01
+	.quad	0x3fe154c3c0000000		# 5.41597247123718261719e-01
+	.quad	0x3fe19ee6a0000000		# 5.50647079944610595703e-01
+	.quad	0x3fe1e85f40000000		# 5.59615731239318847656e-01
+	.quad	0x3fe23130c0000000		# 5.68504691123962402344e-01
+	.quad	0x3fe2795e00000000		# 5.77315330505371093750e-01
+	.quad	0x3fe2c0e9e0000000		# 5.86049020290374755859e-01
+	.quad	0x3fe307d720000000		# 5.94707071781158447266e-01
+	.quad	0x3fe34e2880000000		# 6.03290796279907226562e-01
+	.quad	0x3fe393e0c0000000		# 6.11801505088806152344e-01
+	.quad	0x3fe3d90260000000		# 6.20240390300750732422e-01
+	.quad	0x3fe41d8fe0000000		# 6.28608644008636474609e-01
+	.quad	0x3fe4618bc0000000		# 6.36907458305358886719e-01
+	.quad	0x3fe4a4f840000000		# 6.45137906074523925781e-01
+	.quad	0x3fe4e7d800000000		# 6.53301239013671875000e-01
+	.quad	0x3fe52a2d20000000		# 6.61398470401763916016e-01
+	.quad	0x3fe56bf9c0000000		# 6.69430613517761230469e-01
+	.quad	0x3fe5ad4040000000		# 6.77398800849914550781e-01
+	.quad	0x3fe5ee02a0000000		# 6.85303986072540283203e-01
+	.quad	0x3fe62e42e0000000		# 6.93147122859954833984e-01
+	.quad 0					# for alignment
+
+.L__np_ln_tail_table:
+	.quad	0x00000000000000000 # 0	; 0.00000000000000000000e+00
+	.quad	0x03e361f807c79f3db		# 5.15092497094772879206e-09
+	.quad	0x03e6873c1980267c8		# 4.55457209735272790188e-08
+	.quad	0x03e5ec65b9f88c69e		# 2.86612990859791781788e-08
+	.quad	0x03e58022c54cc2f99		# 2.23596477332056055352e-08
+	.quad	0x03e62c37a3a125330		# 3.49498983167142274770e-08
+	.quad	0x03e615cad69737c93		# 3.23392843005887000414e-08
+	.quad	0x03e4d256ab1b285e9		# 1.35722380472479366661e-08
+	.quad	0x03e5b8abcb97a7aa2		# 2.56504325268044191098e-08
+	.quad	0x03e6f34239659a5dc		# 5.81213608741512136843e-08
+	.quad	0x03e6e07fd48d30177		# 5.59374849578288093334e-08
+	.quad	0x03e6b32df4799f4f6		# 5.06615629004996189970e-08
+	.quad	0x03e6c29e4f4f21cf8		# 5.24588857848400955725e-08
+	.quad	0x03e1086c848df1b59		# 9.61968535632653505972e-10
+	.quad	0x03e4cf456b4764130		# 1.34829655346594463137e-08
+	.quad	0x03e63a02ffcb63398		# 3.65557749306383026498e-08
+	.quad	0x03e61e6a6886b0976		# 3.33431709374069198903e-08
+	.quad	0x03e6b8abcb97a7aa2		# 5.13008650536088382197e-08
+	.quad	0x03e6b578f8aa35552		# 5.09285070380306053751e-08
+	.quad	0x03e6139c871afb9fc		# 3.20853940845502057341e-08
+	.quad	0x03e65d5d30701ce64		# 4.06713248643004200446e-08
+	.quad	0x03e6de7bcb2d12142		# 5.57028186706125221168e-08
+	.quad	0x03e6d708e984e1664		# 5.48356693724804282546e-08
+	.quad	0x03e556945e9c72f36		# 1.99407553679345001938e-08
+	.quad	0x03e20e2f613e85bda		# 1.96585517245087232086e-09
+	.quad	0x03e3cb7e0b42724f6		# 6.68649386072067321503e-09
+	.quad	0x03e6fac04e52846c7		# 5.89936034642113390002e-08
+	.quad	0x03e5e9b14aec442be		# 2.85038578721554472484e-08
+	.quad	0x03e6b5de8034e7126		# 5.09746772910284482606e-08
+	.quad	0x03e6dc157e1b259d3		# 5.54234668933210171467e-08
+	.quad	0x03e3b05096ad69c62		# 6.29100830926604004874e-09
+	.quad	0x03e5c2116faba4cdd		# 2.61974119468563937716e-08
+	.quad	0x03e665fcc25f95b47		# 4.16752115011186398935e-08
+	.quad	0x03e5a9a08498d4850		# 2.47747534460820790327e-08
+	.quad	0x03e6de647b1465f77		# 5.56922172017964209793e-08
+	.quad	0x03e5da71b7bf7861d		# 2.76162876992552906035e-08
+	.quad	0x03e3e6a6886b09760		# 7.08169709942321478061e-09
+	.quad	0x03e6f0075eab0ef64		# 5.77453510221151779025e-08
+	.quad	0x03e33071282fb989b		# 4.43021445893361960146e-09
+	.quad	0x03e60eb43c3f1bed2		# 3.15140984357495864573e-08
+	.quad	0x03e5faf06ecb35c84		# 2.95077445089736670973e-08
+	.quad	0x03e4ef1e63db35f68		# 1.44098510263167149349e-08
+	.quad	0x03e469743fb1a71a5		# 1.05196987538551827693e-08
+	.quad	0x03e6c1cdf404e5796		# 5.23641361722697546261e-08
+	.quad	0x03e4094aa0ada625e		# 7.72099925253243069458e-09
+	.quad	0x03e6e2d4c96fde3ec		# 5.62089493829364197156e-08
+	.quad	0x03e62f4d5e9a98f34		# 3.53090261098577946927e-08
+	.quad	0x03e6467c96ecc5cbe		# 3.80080516835568242269e-08
+	.quad	0x03e6e7040d03dec5a		# 5.66961038386146408282e-08
+	.quad	0x03e67bebf4282de36		# 4.42287063097349852717e-08
+	.quad	0x03e6289b11aeb783f		# 3.45294525105681104660e-08
+	.quad	0x03e5a891d1772f538		# 2.47132034530447431509e-08
+	.quad	0x03e634f10be1fb591		# 3.59655343422487209774e-08
+	.quad	0x03e6d9ce1d316eb93		# 5.51581770357780862071e-08
+	.quad	0x03e63562a19a9c442		# 3.60171867511861372793e-08
+	.quad	0x03e54e2adf548084c		# 1.94511067964296180547e-08
+	.quad	0x03e508ce55cc8c97a		# 1.54137376631349347838e-08
+	.quad	0x03e30e2f613e85bda		# 3.93171034490174464173e-09
+	.quad	0x03e6db03ebb0227bf		# 5.52990607758839766440e-08
+	.quad	0x03e61b75bb09cb098		# 3.29990737637586136511e-08
+	.quad	0x03e496f16abb9df22		# 1.18436010922446096216e-08
+	.quad	0x03e65b3f399411c62		# 4.04248680368301346709e-08
+	.quad	0x03e586b3e59f65355		# 2.27418915900284316293e-08
+	.quad	0x03e52482ceae1ac12		# 1.70263791333409206020e-08
+	.quad	0x03e6efa39ef35793c		# 5.76999904754328540596e-08
+	.quad 0					# for alignment
+
diff --git a/src/gas/vrd4log10.S b/src/gas/vrd4log10.S
new file mode 100644
index 0000000..d0f861c
--- /dev/null
+++ b/src/gas/vrd4log10.S
@@ -0,0 +1,924 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrd4log10.asm
+#
+# A vector implementation of the log10 libm function.
+#
+# Prototype:
+#
+#    __m128d,__m128d __vrd4_log10(__m128d x1, __m128d x2);
+#
+#   Computes the natural log10 of x.
+#   Returns proper C99 values, but may not raise status flags properly.
+#   Less than 1 ulp of error.  This version can compute 4 log10s in
+#   220 cycles, or 55 per value
+#
+# This routine computes 4 double precision log10 values at a time.
+# The four values are passed as packed doubles in xmm0 and xmm1.
+# The four results are returned as packed doubles in xmm0 and xmm1.
+# Note that this represents a non-standard ABI usage, as no ABI
+# ( and indeed C) currently allows returning 2 values for a function.
+# It is expected that some compilers may be able to take advantage of this
+# interface when implementing vectorized loops.  Using the array implementation
+# of the routine requires putting the inputs into memory, and retrieving
+# the results from memory.  This routine eliminates the need for this
+# overhead if the data does not already reside in memory.
+# This routine is derived directly from the array version.
+#
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+
+# define local variable storage offsets
+.equ	p_x,0			# temporary for error checking operation
+.equ	p_idx,0x010		# index storage
+.equ	p_xexp,0x020		# index storage
+
+.equ	p_x2,0x030		# temporary for error checking operation
+.equ	p_idx2,0x040		# index storage
+.equ	p_xexp2,0x050		# index storage
+
+.equ	save_xa,0x060		#qword
+.equ	save_ya,0x068		#qword
+.equ	save_nv,0x070		#qword
+.equ	p_iter,0x078		# qword	storage for number of loop iterations
+
+.equ	save_rbx,0x080		#qword
+
+
+.equ	p2_temp,0x090		# second temporary for get/put bits operation
+.equ	p2_temp1,0x0b0		# second temporary for exponent multiply
+
+.equ	p_n1,0x0c0		# temporary for near one check
+.equ	p_n12,0x0d0		# temporary for near one check
+
+
+.equ	stack_size,0x0e8
+
+
+# parameters are expected as:
+# xmm0 - __m128d x1
+# xmm1 - __m128d x2
+
+    .text
+    .align 16
+    .p2align 4,,15
+.globl __vrd4_log10
+    .type   __vrd4_log10,@function
+__vrd4_log10:
+	sub		$stack_size,%rsp
+	mov		%rbx,save_rbx(%rsp)	# save rdi
+
+# process 4 values at a time.
+
+		movdqa	%xmm1,p_x2(%rsp)	# save the input values
+	movdqa	%xmm0,p_x(%rsp)	# save the input values
+# compute the log10s
+
+##  if NaN or inf
+
+#      /* Store the exponent of x in xexp and put
+#         f into the range [0.5,1) */
+
+	pxor	%xmm1,%xmm1
+	movdqa	%xmm0,%xmm3
+	psrlq	$52,%xmm3
+	psubq	.L__mask_1023(%rip),%xmm3
+	packssdw	%xmm1,%xmm3
+	cvtdq2pd	%xmm3,%xmm6			# xexp
+	movdqa	%xmm0,%xmm2
+	subpd	.L__real_one(%rip),%xmm2
+
+	movapd	%xmm6,p_xexp(%rsp)
+	andpd	.L__real_notsign(%rip),%xmm2
+	xor		%rax,%rax
+
+	movdqa	%xmm0,%xmm3
+	pand	.L__real_mant(%rip),%xmm3
+
+	cmppd	$1,.L__real_threshold(%rip),%xmm2
+	movmskpd	%xmm2,%ecx
+	movdqa	%xmm3,%xmm4
+	mov			%ecx,p_n1(%rsp)
+
+#/* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+	psrlq	$45,%xmm3
+	movdqa	%xmm3,%xmm2
+	psrlq	$1,%xmm3
+	paddq	.L__mask_040(%rip),%xmm3
+	pand	.L__mask_001(%rip),%xmm2
+	paddq	%xmm2,%xmm3
+
+	packssdw	%xmm1,%xmm3
+	cvtdq2pd	%xmm3,%xmm1
+		pxor	%xmm7,%xmm7
+		movdqa	p_x2(%rsp),%xmm2
+		movapd	p_x2(%rsp),%xmm5
+		psrlq	$52,%xmm2
+		psubq	.L__mask_1023(%rip),%xmm2
+		packssdw	%xmm7,%xmm2
+		subpd	.L__real_one(%rip),%xmm5
+		andpd	.L__real_notsign(%rip),%xmm5
+		cvtdq2pd	%xmm2,%xmm6			# xexp
+	xor		%rcx,%rcx
+		cmppd	$1,.L__real_threshold(%rip),%xmm5
+	movq	 %xmm3,p_idx(%rsp)
+
+# reduce and get u
+	por		.L__real_half(%rip),%xmm4
+	movdqa	%xmm4,%xmm2
+		movapd	%xmm6,p_xexp2(%rsp)
+
+	# do near one check
+		movmskpd	%xmm5,%edx
+		mov			%edx,p_n12(%rsp)
+
+	mulpd	.L__real_3f80000000000000(%rip),%xmm1				# f1 = index/128
+
+
+	lea		.L__np_ln_lead_table(%rip),%rdx
+	mov		p_idx(%rsp),%eax
+		movdqa	p_x2(%rsp),%xmm6
+
+	movapd	.L__real_half(%rip),%xmm5							# .5
+	subpd	%xmm1,%xmm2											# f2 = f - f1
+		pand	.L__real_mant(%rip),%xmm6
+	mulpd	%xmm2,%xmm5
+	addpd	%xmm5,%xmm1
+
+		movdqa	%xmm6,%xmm8
+		psrlq	$45,%xmm6
+		movdqa	%xmm6,%xmm4
+
+		psrlq	$1,%xmm6
+		paddq	.L__mask_040(%rip),%xmm6
+		pand	.L__mask_001(%rip),%xmm4
+		paddq	%xmm4,%xmm6
+# do error checking here for scheduling.  Saves a bunch of cycles as
+# compared to doing this at the start of the routine.
+##  if NaN or inf
+	movapd	%xmm0,%xmm3
+	andpd	.L__real_inf(%rip),%xmm3
+	cmppd	$0,.L__real_inf(%rip),%xmm3
+	movmskpd	%xmm3,%r8d
+		packssdw	%xmm7,%xmm6
+		por		.L__real_half(%rip),%xmm8
+		movq	 %xmm6,p_idx2(%rsp)
+		cvtdq2pd	%xmm6,%xmm9
+
+	cmppd	$2,.L__real_zero(%rip),%xmm0
+		mulpd	.L__real_3f80000000000000(%rip),%xmm9				# f1 = index/128
+	movmskpd	%xmm0,%r9d
+# delaying this divide helps, but moving the other one does not.
+# it was after the paddq
+	divpd	%xmm1,%xmm2				# u
+
+# compute the index into the log10 tables
+#
+
+        movlpd   -512(%rdx,%rax,8),%xmm0                # z1
+        mov             p_idx+4(%rsp),%ecx
+        movhpd   -512(%rdx,%rcx,8),%xmm0                # z1
+# solve for ln(1+u)
+	movapd	%xmm2,%xmm1				# u
+	mulpd	%xmm2,%xmm2				# u^2
+	movapd	%xmm2,%xmm5
+	movapd	.L__real_cb3(%rip),%xmm3
+	mulpd	%xmm2,%xmm3				#Cu2
+	mulpd	%xmm1,%xmm5				# u^3
+	addpd	.L__real_cb2(%rip),%xmm3 #B+Cu2
+
+	mulpd	%xmm5,%xmm2				# u^5
+	movapd	.L__real_log2_lead(%rip),%xmm4
+
+	mulpd	.L__real_cb1(%rip),%xmm5 #Au3
+	addpd	%xmm5,%xmm1				# u+Au3
+	mulpd	%xmm3,%xmm2				# u5(B+Cu2)
+
+	movapd	p_xexp(%rsp),%xmm5		# xexp
+	addpd	%xmm2,%xmm1				# poly
+# recombine
+	mulpd	%xmm5,%xmm4				# xexp * log2_lead
+	addpd	%xmm4,%xmm0				#r1
+	movapd  %xmm0,%xmm2				#for log10
+	lea		.L__np_ln_tail_table(%rip),%rdx
+        movlpd   -512(%rdx,%rax,8),%xmm4                #z2     +=q
+        movhpd   -512(%rdx,%rcx,8),%xmm4                #z2     +=q
+        mulpd 	.L__real_log10e_tail(%rip),%xmm0	#for log10
+	    mulpd 	.L__real_log10e_lead(%rip),%xmm2  #for log10
+		lea		.L__np_ln_lead_table(%rip),%rdx
+		mov		p_idx2(%rsp),%eax
+		mov		p_idx2+4(%rsp),%ecx
+	addpd	%xmm4,%xmm1
+
+
+
+	mulpd	.L__real_log2_tail(%rip),%xmm5
+
+		movapd	.L__real_half(%rip),%xmm4							# .5
+
+
+		subpd	%xmm9,%xmm8											# f2 = f - f1
+		mulpd	%xmm8,%xmm4
+		addpd	%xmm4,%xmm9
+
+	addpd	%xmm5,%xmm1				#r2
+		movapd  %xmm1,%xmm7				#for log10
+		mulpd 	.L__real_log10e_tail(%rip),%xmm1 #for log10
+		addpd   %xmm1,%xmm0		#for log10
+
+
+		divpd	%xmm9,%xmm8				# u
+		movapd	p_x2(%rsp),%xmm3
+		mulpd   .L__real_log10e_lead(%rip),%xmm7 #log10
+		andpd	.L__real_inf(%rip),%xmm3
+
+		cmppd	$0,.L__real_inf(%rip),%xmm3
+		movmskpd	%xmm3,%r10d
+		addpd   %xmm7,%xmm0		#for log10
+		movapd	p_x2(%rsp),%xmm6
+		cmppd	$2,.L__real_zero(%rip),%xmm6
+		movmskpd	%xmm6,%r11d
+
+
+
+
+# check for nans/infs
+	test		$3,%r8d
+	addpd  %xmm2,%xmm0	#for log10
+#	addpd	%xmm1,%xmm0
+	jnz		.L__log_naninf
+.L__vlog1:
+# check for negative numbers or zero
+	test		$3,%r9d
+	jnz		.L__z_or_n
+
+
+.L__vlog2:
+
+
+	# It seems like a good idea to try and interleave
+	# even more of the following code sooner into the
+	# program.  But there were conflicts with the table
+	# index registers, making the problem difficult.
+	# After a lot of work in a branch of this file,
+	# I was not able to match the speed of this version.
+	# CodeAnalyst shows that there is lots of unused add
+	# pipe time around the divides, but the processor
+	# doesn't seem to be able to schedule in those slots.
+
+	        movlpd   -512(%rdx,%rax,8),%xmm7                #z2     +=q
+        	movhpd   -512(%rdx,%rcx,8),%xmm7                #z2     +=q
+
+# check for near one
+	mov			p_n1(%rsp),%r9d
+	test			$3,%r9d
+	jnz			.L__near_one1
+.L__vlog2n:
+
+
+	# solve for ln(1+u)
+		movapd	%xmm8,%xmm9				# u
+		mulpd	%xmm8,%xmm8				# u^2
+		movapd	%xmm8,%xmm5
+		movapd	.L__real_cb3(%rip),%xmm3
+		mulpd	%xmm8,%xmm3				#Cu2
+		mulpd	%xmm9,%xmm5				# u^3
+		addpd	.L__real_cb2(%rip),%xmm3 		#B+Cu2
+
+		mulpd	%xmm5,%xmm8				# u^5
+		movapd	.L__real_log2_lead(%rip),%xmm4
+
+		mulpd	.L__real_cb1(%rip),%xmm5 		#Au3
+		addpd	%xmm5,%xmm9				# u+Au3
+		mulpd	%xmm3,%xmm8				# u5(B+Cu2)
+
+		movapd	p_xexp2(%rsp),%xmm5			# xexp
+		addpd	%xmm8,%xmm9				# poly
+	# recombine
+		mulpd	%xmm5,%xmm4
+		addpd	%xmm4,%xmm7				#r1
+		movapd 	%xmm7,%xmm6			#for log10
+
+		lea		.L__np_ln_tail_table(%rip),%rdx
+		mulpd 	.L__real_log10e_tail(%rip),%xmm7 #for log10
+	        movlpd   -512(%rdx,%rax,8),%xmm2                #z2     +=q
+	    mulpd 	.L__real_log10e_lead(%rip),%xmm6 #for log10
+        	movhpd   -512(%rdx,%rcx,8),%xmm2                #z2     +=q
+		addpd	%xmm2,%xmm9
+
+		mulpd	.L__real_log2_tail(%rip),%xmm5
+
+		addpd	%xmm5,%xmm9				#r2
+		movapd  %xmm9,%xmm8				#for log10
+		mulpd 	.L__real_log10e_tail(%rip),%xmm9 #for log 10
+		addpd   %xmm9,%xmm7 	#for log10
+		mulpd 	.L__real_log10e_lead(%rip),%xmm8 #for log10
+		addpd	%xmm8,%xmm7 	#for log10
+
+	# check for nans/infs
+		test		$3,%r10d
+		addpd   %xmm6,%xmm7	#for log10
+#		addpd	%xmm9,%xmm7
+		jnz		.L__log_naninf2
+.L__vlog3:
+# check for negative numbers or zero
+		test		$3,%r11d
+		jnz		.L__z_or_n2
+
+.L__vlog4:
+
+
+	mov			p_n12(%rsp),%r9d
+	test			$3,%r9d
+	jnz			.L__near_one2
+
+.L__vlog4n:
+
+# store the result _m128d
+		movapd	%xmm7,%xmm1
+
+
+.L__finish:
+	mov		save_rbx(%rsp),%rbx		# restore rbx
+	add		$stack_size,%rsp
+	ret
+
+	.align	16
+.Lboth_nearone:
+# saves 10 cycles
+#      r = x - 1.0;
+	movapd	.L__real_two(%rip),%xmm2
+	subpd	.L__real_one(%rip),%xmm0	   # r
+#      u          = r / (2.0 + r);
+	addpd	%xmm0,%xmm2
+	movapd	%xmm0,%xmm1
+	divpd	%xmm2,%xmm1		# u
+	movapd	.L__real_ca4(%rip),%xmm4	  #D
+	movapd	.L__real_ca3(%rip),%xmm5	  #C
+#      correction = r * u;
+	movapd	%xmm0,%xmm6
+	mulpd	%xmm1,%xmm6		# correction
+#      u          = u + u;
+	addpd	%xmm1,%xmm1		#u
+	movapd	%xmm1,%xmm2
+	mulpd	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulpd	%xmm1,%xmm5		# Cu
+	movapd	%xmm1,%xmm3
+	mulpd	%xmm2,%xmm3		# u^3
+	mulpd	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulpd	%xmm3,%xmm4		#Du^3
+
+	addpd	.L__real_ca1(%rip),%xmm2	# +A
+	movapd	%xmm3,%xmm1
+	mulpd	%xmm1,%xmm1		# u^6
+	addpd	%xmm4,%xmm5		#Cu+Du3
+
+	mulpd	%xmm3,%xmm2		#u3(A+Bu2)
+	mulpd	%xmm5,%xmm1		#u6(Cu+Du3)
+	addpd	%xmm1,%xmm2
+	subpd	%xmm6,%xmm2		# -correction
+
+#	loge to log10
+	movapd 	%xmm0,%xmm3		#r1 = r
+	pand	.L__mask_lower(%rip),%xmm3
+	subpd	%xmm3,%xmm0
+	addpd 	%xmm0,%xmm2		#r2 = r2 + (r - r1);
+
+	movapd 	%xmm3,%xmm0
+	movapd	%xmm2,%xmm1
+
+	mulpd 	.L__real_log10e_tail(%rip),%xmm2
+	mulpd 	.L__real_log10e_tail(%rip),%xmm0
+	mulpd 	.L__real_log10e_lead(%rip),%xmm1
+	mulpd 	.L__real_log10e_lead(%rip),%xmm3
+	addpd 	%xmm2,%xmm0
+	addpd 	%xmm1,%xmm0
+	addpd	%xmm3,%xmm0
+#      return r + r2;
+#	addpd	%xmm2,%xmm0
+	ret
+
+	.align	16
+.L__near_one1:
+	cmp	$3,%r9d
+	jnz		.L__n1nb1
+
+	movapd	p_x(%rsp),%xmm0
+	call	.Lboth_nearone
+	jmp		.L__vlog2n
+
+	.align	16
+.L__n1nb1:
+	test	$1,%r9d
+	jz		.L__lnn12
+
+	movlpd	p_x(%rsp),%xmm0
+	call	.L__ln1
+
+.L__lnn12:
+	test	$2,%r9d		# second number?
+	jz		.L__lnn1e
+	movlpd	%xmm0,p_x(%rsp)
+	movlpd	p_x+8(%rsp),%xmm0
+	call	.L__ln1
+	movlpd	%xmm0,p_x+8(%rsp)
+	movapd	p_x(%rsp),%xmm0
+
+.L__lnn1e:
+	jmp		.L__vlog2n
+
+
+	.align	16
+.L__near_one2:
+	cmp	$3,%r9d
+	jnz		.L__n1nb2
+
+	movapd	%xmm0,%xmm8
+	movapd	p_x2(%rsp),%xmm0
+	call	.Lboth_nearone
+	movapd	%xmm0,%xmm7
+	movapd	%xmm8,%xmm0
+	jmp		.L__vlog4n
+
+	.align	16
+.L__n1nb2:
+	movapd	%xmm0,%xmm8
+	test	$1,%r9d
+	jz		.L__lnn22
+
+	movapd	%xmm7,%xmm0
+	movlpd	p_x2(%rsp),%xmm0
+	call	.L__ln1
+	movapd	%xmm0,%xmm7
+
+.L__lnn22:
+	test	$2,%r9d		# second number?
+	jz		.L__lnn2e
+	movlpd	%xmm7,p_x2(%rsp)
+	movlpd	p_x2+8(%rsp),%xmm0
+	call	.L__ln1
+	movlpd	%xmm0,p_x2+8(%rsp)
+	movapd	p_x2(%rsp),%xmm7
+
+.L__lnn2e:
+	movapd	%xmm8,%xmm0
+	jmp		.L__vlog4n
+
+	.align	16
+
+.L__ln1:
+# saves 10 cycles
+#      r = x - 1.0;
+	movlpd	.L__real_two(%rip),%xmm2
+	subsd	.L__real_one(%rip),%xmm0	   # r
+#      u          = r / (2.0 + r);
+	addsd	%xmm0,%xmm2
+	movsd	%xmm0,%xmm1
+	divsd	%xmm2,%xmm1		# u
+	movlpd	.L__real_ca4(%rip),%xmm4	  #D
+	movlpd	.L__real_ca3(%rip),%xmm5	  #C
+#      correction = r * u;
+	movsd	%xmm0,%xmm6
+	mulsd	%xmm1,%xmm6		# correction
+#      u          = u + u;
+	addsd	%xmm1,%xmm1		#u
+	movsd	%xmm1,%xmm2
+	mulsd	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulsd	%xmm1,%xmm5		# Cu
+	movsd	%xmm1,%xmm3
+	mulsd	%xmm2,%xmm3		# u^3
+	mulsd	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulsd	%xmm3,%xmm4		#Du^3
+
+	addsd	.L__real_ca1(%rip),%xmm2	# +A
+	movsd	%xmm3,%xmm1
+	mulsd	%xmm1,%xmm1		# u^6
+	addsd	%xmm4,%xmm5		#Cu+Du3
+
+	mulsd	%xmm3,%xmm2		#u3(A+Bu2)
+	mulsd	%xmm5,%xmm1		#u6(Cu+Du3)
+	addsd	%xmm1,%xmm2
+	subsd	%xmm6,%xmm2		# -correction
+
+#	loge to log10
+	movsd 	%xmm0,%xmm3		#r1 = r
+	pand	.L__mask_lower(%rip),%xmm3
+	subsd	%xmm3,%xmm0
+	addsd 	%xmm0,%xmm2		#r2 = r2 + (r - r1);
+
+	movsd 	%xmm3,%xmm0
+	movsd	%xmm2,%xmm1
+
+	mulsd 	.L__real_log10e_tail(%rip),%xmm2
+	mulsd 	.L__real_log10e_tail(%rip),%xmm0
+	mulsd 	.L__real_log10e_lead(%rip),%xmm1
+	mulsd 	.L__real_log10e_lead(%rip),%xmm3
+	addsd 	%xmm2,%xmm0
+	addsd 	%xmm1,%xmm0
+	addsd	%xmm3,%xmm0
+
+#      return r + r2;
+#	addsd	%xmm2,%xmm0
+	ret
+
+	.align	16
+
+# at least one of the numbers was a nan or infinity
+.L__log_naninf:
+	test		$1,%r8d		# first number?
+	jz		.L__lninf2
+
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x(%rsp),%rdx
+	movlpd	p_x(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$2,%xmm1,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__lninf2:
+	test		$2,%r8d		# second number?
+	jz		.L__lninfe
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x+8(%rsp),%rdx
+	movlpd	p_x+8(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$0,%xmm0,%xmm1
+	movapd	%xmm1,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__lninfe:
+	jmp		.L__vlog1		# continue processing if not
+
+# at least one of the numbers was a nan or infinity
+.L__log_naninf2:
+	movapd	%xmm0,%xmm2
+	test		$1,%r10d		# first number?
+	jz		.L__lninf22
+
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm7,%xmm1		# save the inputs
+	mov		p_x2(%rsp),%rdx
+	movlpd	p_x2(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$2,%xmm7,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+	movapd	%xmm0,%xmm7
+
+.L__lninf22:
+	test		$2,%r10d		# second number?
+	jz		.L__lninfe2
+
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	mov		p_x2+8(%rsp),%rdx
+	movlpd	p_x2+8(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$0,%xmm0,%xmm7
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__lninfe2:
+	movapd	%xmm2,%xmm0
+	jmp		.L__vlog3		# continue processing if not
+
+# a subroutine to treat one number for nan/infinity
+# the number is expected in rdx and returned in the low
+# half of xmm0
+.L__lni:
+	mov		$0x0000FFFFFFFFFFFFF,%rax
+	test	%rax,%rdx
+	jnz		.L__lnan					# jump if mantissa not zero, so it's a NaN
+# inf
+	rcl		$1,%rdx
+	jnc		.L__lne2					# log(+inf) = inf
+# negative x
+	movlpd	.L__real_nan(%rip),%xmm0
+	ret
+
+#NaN
+.L__lnan:
+	mov		$0x00008000000000000,%rax	# convert to quiet
+	or		%rax,%rdx
+.L__lne:
+	movd	%rdx,%xmm0
+.L__lne2:
+	ret
+
+	.align	16
+
+# at least one of the numbers was a zero, a negative number, or both.
+.L__z_or_n:
+	test		$1,%r9d		# first number?
+	jz		.L__zn2
+
+	mov		%rax,p2_temp(%rsp)
+ 	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x(%rsp),%rax
+	call	.L__zni
+	shufpd	$2,%xmm1,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__zn2:
+	test		$2,%r9d		# second number?
+	jz		.L__zne
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x+8(%rsp),%rax
+	call	.L__zni
+	shufpd	$0,%xmm0,%xmm1
+	movapd	%xmm1,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__zne:
+	jmp		.L__vlog2
+
+.L__z_or_n2:
+	movapd	%xmm0,%xmm2
+	test		$1,%r11d		# first number?
+	jz		.L__zn22
+
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	mov		p_x2(%rsp),%rax
+	call	.L__zni
+	shufpd	$2,%xmm7,%xmm0
+	movapd	%xmm0,%xmm7
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__zn22:
+	test		$2,%r11d		# second number?
+	jz		.L__zne2
+
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	mov		p_x2+8(%rsp),%rax
+	call	.L__zni
+	shufpd	$0,%xmm0,%xmm7
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__zne2:
+	movapd	%xmm2,%xmm0
+	jmp		.L__vlog4
+# a subroutine to treat one number for zero or negative values
+# the number is expected in rax and returned in the low
+# half of xmm0
+.L__zni:
+	shl		$1,%rax
+	jnz		.L__zn_x		 ## if just a carry, then must be negative
+	movlpd	.L__real_ninf(%rip),%xmm0  # C99 specs -inf for +-0
+	ret
+.L__zn_x:
+	movlpd	.L__real_nan(%rip),%xmm0
+	ret
+
+
+
+	.data
+	.align	16
+
+.L__real_one:				.quad 0x03ff0000000000000	# 1.0
+						.quad 0x03ff0000000000000					# for alignment
+.L__real_two:				.quad 0x04000000000000000	# 1.0
+						.quad 0x04000000000000000
+.L__real_ninf:				.quad 0x0fff0000000000000	# -inf
+						.quad 0x0fff0000000000000
+.L__real_inf:				.quad 0x07ff0000000000000	# +inf
+						.quad 0x07ff0000000000000
+.L__real_nan:				.quad 0x07ff8000000000000	# NaN
+						.quad 0x07ff8000000000000
+
+.L__real_zero:				.quad 0x00000000000000000	# 0.0
+						.quad 0x00000000000000000
+
+.L__real_sign:				.quad 0x08000000000000000	# sign bit
+						.quad 0x08000000000000000
+.L__real_notsign:			.quad 0x07ffFFFFFFFFFFFFF	# ^sign bit
+						.quad 0x07ffFFFFFFFFFFFFF
+.L__real_threshold:		.quad 0x03FB082C000000000	# .064495086669921875 Threshold
+				.quad 0x03FB082C000000000
+.L__real_qnanbit:			.quad 0x00008000000000000	# quiet nan bit
+						.quad 0x00008000000000000
+.L__real_mant:				.quad 0x0000FFFFFFFFFFFFF	# mantissa bits
+						.quad 0x0000FFFFFFFFFFFFF
+.L__real_3f80000000000000:	.quad 0x03f80000000000000	# /* 0.0078125 = 1/128 */
+						.quad 0x03f80000000000000
+.L__mask_1023:				.quad 0x000000000000003ff	#
+						.quad 0x000000000000003ff
+.L__mask_040:				.quad 0x00000000000000040	#
+						.quad 0x00000000000000040
+.L__mask_001:				.quad 0x00000000000000001	#
+						.quad 0x00000000000000001
+
+.L__real_ca1:				.quad 0x03fb55555555554e6	# 8.33333333333317923934e-02
+						.quad 0x03fb55555555554e6
+.L__real_ca2:				.quad 0x03f89999999bac6d4	# 1.25000000037717509602e-02
+						.quad 0x03f89999999bac6d4
+.L__real_ca3:				.quad 0x03f62492307f1519f	# 2.23213998791944806202e-03
+						.quad 0x03f62492307f1519f
+.L__real_ca4:				.quad 0x03f3c8034c85dfff0	# 4.34887777707614552256e-04
+						.quad 0x03f3c8034c85dfff0
+
+
+.L__real_cb1:				.quad 0x03fb5555555555557	# 8.33333333333333593622e-02
+						.quad 0x03fb5555555555557
+.L__real_cb2:				.quad 0x03f89999999865ede	# 1.24999999978138668903e-02
+						.quad 0x03f89999999865ede
+.L__real_cb3:				.quad 0x03f6249423bd94741	# 2.23219810758559851206e-03
+						.quad 0x03f6249423bd94741
+.L__real_log2_lead:  		.quad 0x03fe62e42e0000000	# log2_lead	  6.93147122859954833984e-01
+						.quad 0x03fe62e42e0000000
+.L__real_log2_tail: 		.quad 0x03e6efa39ef35793c	# log2_tail	  5.76999904754328540596e-08
+						.quad 0x03e6efa39ef35793c
+
+.L__real_half:				.quad 0x03fe0000000000000	# 1/2
+						.quad 0x03fe0000000000000
+
+.L__real_log10e_lead:	.quad 0x03fdbcb7800000000	# log10e_lead 4.34293746948242187500e-01
+				.quad 0x03fdbcb7800000000
+.L__real_log10e_tail:	.quad 0x03ea8a93728719535	# log10e_tail 7.3495500964015109100644e-7
+				.quad 0x03ea8a93728719535
+
+.L__mask_lower:			.quad 0x0ffffffff00000000
+				.quad 0x0ffffffff00000000
+	.align	16
+
+.L__np_ln_lead_table:
+	.quad	0x0000000000000000 		# 0.00000000000000000000e+00
+	.quad	0x3f8fc0a800000000		# 1.55041813850402832031e-02
+	.quad	0x3f9f829800000000		# 3.07716131210327148438e-02
+	.quad	0x3fa7745800000000		# 4.58095073699951171875e-02
+	.quad	0x3faf0a3000000000		# 6.06245994567871093750e-02
+	.quad	0x3fb341d700000000		# 7.52233862876892089844e-02
+	.quad	0x3fb6f0d200000000		# 8.96121263504028320312e-02
+	.quad	0x3fba926d00000000		# 1.03796780109405517578e-01
+	.quad	0x3fbe270700000000		# 1.17783010005950927734e-01
+	.quad	0x3fc0d77e00000000		# 1.31576299667358398438e-01
+	.quad	0x3fc2955280000000		# 1.45181953907012939453e-01
+	.quad	0x3fc44d2b00000000		# 1.58604979515075683594e-01
+	.quad	0x3fc5ff3000000000		# 1.71850204467773437500e-01
+	.quad	0x3fc7ab8900000000		# 1.84922337532043457031e-01
+	.quad	0x3fc9525a80000000		# 1.97825729846954345703e-01
+	.quad	0x3fcaf3c900000000		# 2.10564732551574707031e-01
+	.quad	0x3fcc8ff780000000		# 2.23143517971038818359e-01
+	.quad	0x3fce270700000000		# 2.35566020011901855469e-01
+	.quad	0x3fcfb91800000000		# 2.47836112976074218750e-01
+	.quad	0x3fd0a324c0000000		# 2.59957492351531982422e-01
+	.quad	0x3fd1675c80000000		# 2.71933674812316894531e-01
+	.quad	0x3fd22941c0000000		# 2.83768117427825927734e-01
+	.quad	0x3fd2e8e280000000		# 2.95464158058166503906e-01
+	.quad	0x3fd3a64c40000000		# 3.07025015354156494141e-01
+	.quad	0x3fd4618bc0000000		# 3.18453729152679443359e-01
+	.quad	0x3fd51aad80000000		# 3.29753279685974121094e-01
+	.quad	0x3fd5d1bd80000000		# 3.40926527976989746094e-01
+	.quad	0x3fd686c800000000		# 3.51976394653320312500e-01
+	.quad	0x3fd739d7c0000000		# 3.62905442714691162109e-01
+	.quad	0x3fd7eaf800000000		# 3.73716354370117187500e-01
+	.quad	0x3fd89a3380000000		# 3.84411692619323730469e-01
+	.quad	0x3fd9479400000000		# 3.94993782043457031250e-01
+	.quad	0x3fd9f323c0000000		# 4.05465066432952880859e-01
+	.quad	0x3fda9cec80000000		# 4.15827870368957519531e-01
+	.quad	0x3fdb44f740000000		# 4.26084339618682861328e-01
+	.quad	0x3fdbeb4d80000000		# 4.36236739158630371094e-01
+	.quad	0x3fdc8ff7c0000000		# 4.46287095546722412109e-01
+	.quad	0x3fdd32fe40000000		# 4.56237375736236572266e-01
+	.quad	0x3fddd46a00000000		# 4.66089725494384765625e-01
+	.quad	0x3fde744240000000		# 4.75845873355865478516e-01
+	.quad	0x3fdf128f40000000		# 4.85507786273956298828e-01
+	.quad	0x3fdfaf5880000000		# 4.95077252388000488281e-01
+	.quad	0x3fe02552a0000000		# 5.04556000232696533203e-01
+	.quad	0x3fe0723e40000000		# 5.13945698738098144531e-01
+	.quad	0x3fe0be72e0000000		# 5.23248136043548583984e-01
+	.quad	0x3fe109f380000000		# 5.32464742660522460938e-01
+	.quad	0x3fe154c3c0000000		# 5.41597247123718261719e-01
+	.quad	0x3fe19ee6a0000000		# 5.50647079944610595703e-01
+	.quad	0x3fe1e85f40000000		# 5.59615731239318847656e-01
+	.quad	0x3fe23130c0000000		# 5.68504691123962402344e-01
+	.quad	0x3fe2795e00000000		# 5.77315330505371093750e-01
+	.quad	0x3fe2c0e9e0000000		# 5.86049020290374755859e-01
+	.quad	0x3fe307d720000000		# 5.94707071781158447266e-01
+	.quad	0x3fe34e2880000000		# 6.03290796279907226562e-01
+	.quad	0x3fe393e0c0000000		# 6.11801505088806152344e-01
+	.quad	0x3fe3d90260000000		# 6.20240390300750732422e-01
+	.quad	0x3fe41d8fe0000000		# 6.28608644008636474609e-01
+	.quad	0x3fe4618bc0000000		# 6.36907458305358886719e-01
+	.quad	0x3fe4a4f840000000		# 6.45137906074523925781e-01
+	.quad	0x3fe4e7d800000000		# 6.53301239013671875000e-01
+	.quad	0x3fe52a2d20000000		# 6.61398470401763916016e-01
+	.quad	0x3fe56bf9c0000000		# 6.69430613517761230469e-01
+	.quad	0x3fe5ad4040000000		# 6.77398800849914550781e-01
+	.quad	0x3fe5ee02a0000000		# 6.85303986072540283203e-01
+	.quad	0x3fe62e42e0000000		# 6.93147122859954833984e-01
+	.quad 0					# for alignment
+
+.L__np_ln_tail_table:
+	.quad	0x00000000000000000 # 0	; 0.00000000000000000000e+00
+	.quad	0x03e361f807c79f3db		# 5.15092497094772879206e-09
+	.quad	0x03e6873c1980267c8		# 4.55457209735272790188e-08
+	.quad	0x03e5ec65b9f88c69e		# 2.86612990859791781788e-08
+	.quad	0x03e58022c54cc2f99		# 2.23596477332056055352e-08
+	.quad	0x03e62c37a3a125330		# 3.49498983167142274770e-08
+	.quad	0x03e615cad69737c93		# 3.23392843005887000414e-08
+	.quad	0x03e4d256ab1b285e9		# 1.35722380472479366661e-08
+	.quad	0x03e5b8abcb97a7aa2		# 2.56504325268044191098e-08
+	.quad	0x03e6f34239659a5dc		# 5.81213608741512136843e-08
+	.quad	0x03e6e07fd48d30177		# 5.59374849578288093334e-08
+	.quad	0x03e6b32df4799f4f6		# 5.06615629004996189970e-08
+	.quad	0x03e6c29e4f4f21cf8		# 5.24588857848400955725e-08
+	.quad	0x03e1086c848df1b59		# 9.61968535632653505972e-10
+	.quad	0x03e4cf456b4764130		# 1.34829655346594463137e-08
+	.quad	0x03e63a02ffcb63398		# 3.65557749306383026498e-08
+	.quad	0x03e61e6a6886b0976		# 3.33431709374069198903e-08
+	.quad	0x03e6b8abcb97a7aa2		# 5.13008650536088382197e-08
+	.quad	0x03e6b578f8aa35552		# 5.09285070380306053751e-08
+	.quad	0x03e6139c871afb9fc		# 3.20853940845502057341e-08
+	.quad	0x03e65d5d30701ce64		# 4.06713248643004200446e-08
+	.quad	0x03e6de7bcb2d12142		# 5.57028186706125221168e-08
+	.quad	0x03e6d708e984e1664		# 5.48356693724804282546e-08
+	.quad	0x03e556945e9c72f36		# 1.99407553679345001938e-08
+	.quad	0x03e20e2f613e85bda		# 1.96585517245087232086e-09
+	.quad	0x03e3cb7e0b42724f6		# 6.68649386072067321503e-09
+	.quad	0x03e6fac04e52846c7		# 5.89936034642113390002e-08
+	.quad	0x03e5e9b14aec442be		# 2.85038578721554472484e-08
+	.quad	0x03e6b5de8034e7126		# 5.09746772910284482606e-08
+	.quad	0x03e6dc157e1b259d3		# 5.54234668933210171467e-08
+	.quad	0x03e3b05096ad69c62		# 6.29100830926604004874e-09
+	.quad	0x03e5c2116faba4cdd		# 2.61974119468563937716e-08
+	.quad	0x03e665fcc25f95b47		# 4.16752115011186398935e-08
+	.quad	0x03e5a9a08498d4850		# 2.47747534460820790327e-08
+	.quad	0x03e6de647b1465f77		# 5.56922172017964209793e-08
+	.quad	0x03e5da71b7bf7861d		# 2.76162876992552906035e-08
+	.quad	0x03e3e6a6886b09760		# 7.08169709942321478061e-09
+	.quad	0x03e6f0075eab0ef64		# 5.77453510221151779025e-08
+	.quad	0x03e33071282fb989b		# 4.43021445893361960146e-09
+	.quad	0x03e60eb43c3f1bed2		# 3.15140984357495864573e-08
+	.quad	0x03e5faf06ecb35c84		# 2.95077445089736670973e-08
+	.quad	0x03e4ef1e63db35f68		# 1.44098510263167149349e-08
+	.quad	0x03e469743fb1a71a5		# 1.05196987538551827693e-08
+	.quad	0x03e6c1cdf404e5796		# 5.23641361722697546261e-08
+	.quad	0x03e4094aa0ada625e		# 7.72099925253243069458e-09
+	.quad	0x03e6e2d4c96fde3ec		# 5.62089493829364197156e-08
+	.quad	0x03e62f4d5e9a98f34		# 3.53090261098577946927e-08
+	.quad	0x03e6467c96ecc5cbe		# 3.80080516835568242269e-08
+	.quad	0x03e6e7040d03dec5a		# 5.66961038386146408282e-08
+	.quad	0x03e67bebf4282de36		# 4.42287063097349852717e-08
+	.quad	0x03e6289b11aeb783f		# 3.45294525105681104660e-08
+	.quad	0x03e5a891d1772f538		# 2.47132034530447431509e-08
+	.quad	0x03e634f10be1fb591		# 3.59655343422487209774e-08
+	.quad	0x03e6d9ce1d316eb93		# 5.51581770357780862071e-08
+	.quad	0x03e63562a19a9c442		# 3.60171867511861372793e-08
+	.quad	0x03e54e2adf548084c		# 1.94511067964296180547e-08
+	.quad	0x03e508ce55cc8c97a		# 1.54137376631349347838e-08
+	.quad	0x03e30e2f613e85bda		# 3.93171034490174464173e-09
+	.quad	0x03e6db03ebb0227bf		# 5.52990607758839766440e-08
+	.quad	0x03e61b75bb09cb098		# 3.29990737637586136511e-08
+	.quad	0x03e496f16abb9df22		# 1.18436010922446096216e-08
+	.quad	0x03e65b3f399411c62		# 4.04248680368301346709e-08
+	.quad	0x03e586b3e59f65355		# 2.27418915900284316293e-08
+	.quad	0x03e52482ceae1ac12		# 1.70263791333409206020e-08
+	.quad	0x03e6efa39ef35793c		# 5.76999904754328540596e-08
+	.quad 0					# for alignment
+
diff --git a/src/gas/vrd4log2.S b/src/gas/vrd4log2.S
new file mode 100644
index 0000000..bc254cf
--- /dev/null
+++ b/src/gas/vrd4log2.S
@@ -0,0 +1,908 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrd4log2.asm
+#
+# A vector implementation of the log libm function.
+#
+# Prototype:
+#
+#    __m128d,__m128d __vrd4_log2(__m128d x1, __m128d x2);
+#
+#   Computes the natural log of x.
+#   Returns proper C99 values, but may not raise status flags properly.
+#   Less than 1 ulp of error.  This version can compute 4 logs in
+#   192 cycles, or 48 per value
+#
+# This routine computes 4 double precision log values at a time.
+# The four values are passed as packed doubles in xmm0 and xmm1.
+# The four results are returned as packed doubles in xmm0 and xmm1.
+# Note that this represents a non-standard ABI usage, as no ABI
+# ( and indeed C) currently allows returning 2 values for a function.
+# It is expected that some compilers may be able to take advantage of this
+# interface when implementing vectorized loops.  Using the array implementation
+# of the routine requires putting the inputs into memory, and retrieving
+# the results from memory.  This routine eliminates the need for this
+# overhead if the data does not already reside in memory.
+# This routine is derived directly from the array version.
+#
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+
+# define local variable storage offsets
+.equ	p_x,0			# temporary for error checking operation
+.equ	p_idx,0x010		# index storage
+.equ	p_xexp,0x020		# index storage
+
+.equ	p_x2,0x030		# temporary for error checking operation
+.equ	p_idx2,0x040		# index storage
+.equ	p_xexp2,0x050		# index storage
+
+.equ	save_xa,0x060		#qword
+.equ	save_ya,0x068		#qword
+.equ	save_nv,0x070		#qword
+.equ	p_iter,0x078		# qword	storage for number of loop iterations
+
+.equ	save_rbx,0x080		#qword
+
+
+.equ	p2_temp,0x090		# second temporary for get/put bits operation
+.equ	p2_temp1,0x0b0		# second temporary for exponent multiply
+
+.equ	p_n1,0x0c0		# temporary for near one check
+.equ	p_n12,0x0d0		# temporary for near one check
+
+
+.equ	stack_size,0x0e8
+
+
+# parameters are expected as:
+# xmm0 - __m128d x1
+# xmm1 - __m128d x2
+
+    .text
+    .align 16
+    .p2align 4,,15
+.globl __vrd4_log2
+    .type   __vrd4_log2,@function
+__vrd4_log2:
+	sub		$stack_size,%rsp
+	mov		%rbx,save_rbx(%rsp)	# save rdi
+
+# process 4 values at a time.
+
+		movdqa	%xmm1,p_x2(%rsp)	# save the input values
+	movdqa	%xmm0,p_x(%rsp)	# save the input values
+# compute the logs
+
+##  if NaN or inf
+
+#      /* Store the exponent of x in xexp and put
+#         f into the range [0.5,1) */
+
+	pxor	%xmm1,%xmm1
+	movdqa	%xmm0,%xmm3
+	psrlq	$52,%xmm3
+	psubq	.L__mask_1023(%rip),%xmm3
+	packssdw	%xmm1,%xmm3
+	cvtdq2pd	%xmm3,%xmm6			# xexp
+	movdqa	%xmm0,%xmm2
+	subpd	.L__real_one(%rip),%xmm2
+
+	movapd	%xmm6,p_xexp(%rsp)
+	andpd	.L__real_notsign(%rip),%xmm2
+	xor		%rax,%rax
+
+	movdqa	%xmm0,%xmm3
+	pand	.L__real_mant(%rip),%xmm3
+
+	cmppd	$1,.L__real_threshold(%rip),%xmm2
+	movmskpd	%xmm2,%ecx
+	movdqa	%xmm3,%xmm4
+	mov			%ecx,p_n1(%rsp)
+
+#/* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+	psrlq	$45,%xmm3
+	movdqa	%xmm3,%xmm2
+	psrlq	$1,%xmm3
+	paddq	.L__mask_040(%rip),%xmm3
+	pand	.L__mask_001(%rip),%xmm2
+	paddq	%xmm2,%xmm3
+
+	packssdw	%xmm1,%xmm3
+	cvtdq2pd	%xmm3,%xmm1
+		pxor	%xmm7,%xmm7
+		movdqa	p_x2(%rsp),%xmm2
+		movapd	p_x2(%rsp),%xmm5
+		psrlq	$52,%xmm2
+		psubq	.L__mask_1023(%rip),%xmm2
+		packssdw	%xmm7,%xmm2
+		subpd	.L__real_one(%rip),%xmm5
+		andpd	.L__real_notsign(%rip),%xmm5
+		cvtdq2pd	%xmm2,%xmm6			# xexp
+	xor		%rcx,%rcx
+		cmppd	$1,.L__real_threshold(%rip),%xmm5
+	movq	 %xmm3,p_idx(%rsp)
+
+# reduce and get u
+	por		.L__real_half(%rip),%xmm4
+	movdqa	%xmm4,%xmm2
+		movapd	%xmm6,p_xexp2(%rsp)
+
+	# do near one check
+		movmskpd	%xmm5,%edx
+		mov			%edx,p_n12(%rsp)
+
+	mulpd	.L__real_3f80000000000000(%rip),%xmm1				# f1 = index/128
+
+
+	lea		.L__np_ln_lead_table(%rip),%rdx
+	mov		p_idx(%rsp),%eax
+		movdqa	p_x2(%rsp),%xmm6
+
+	movapd	.L__real_half(%rip),%xmm5							# .5
+	subpd	%xmm1,%xmm2											# f2 = f - f1
+		pand	.L__real_mant(%rip),%xmm6
+	mulpd	%xmm2,%xmm5
+	addpd	%xmm5,%xmm1
+
+		movdqa	%xmm6,%xmm8
+		psrlq	$45,%xmm6
+		movdqa	%xmm6,%xmm4
+
+		psrlq	$1,%xmm6
+		paddq	.L__mask_040(%rip),%xmm6
+		pand	.L__mask_001(%rip),%xmm4
+		paddq	%xmm4,%xmm6
+# do error checking here for scheduling.  Saves a bunch of cycles as
+# compared to doing this at the start of the routine.
+##  if NaN or inf
+	movapd	%xmm0,%xmm3
+	andpd	.L__real_inf(%rip),%xmm3
+	cmppd	$0,.L__real_inf(%rip),%xmm3
+	movmskpd	%xmm3,%r8d
+		packssdw	%xmm7,%xmm6
+		por		.L__real_half(%rip),%xmm8
+		movq	 %xmm6,p_idx2(%rsp)
+		cvtdq2pd	%xmm6,%xmm9
+
+	cmppd	$2,.L__real_zero(%rip),%xmm0
+		mulpd	.L__real_3f80000000000000(%rip),%xmm9				# f1 = index/128
+	movmskpd	%xmm0,%r9d
+# delaying this divide helps, but moving the other one does not.
+# it was after the paddq
+	divpd	%xmm1,%xmm2				# u
+
+# compute the index into the log tables
+#
+
+        movlpd   -512(%rdx,%rax,8),%xmm0                # z1
+        mov             p_idx+4(%rsp),%ecx
+        movhpd   -512(%rdx,%rcx,8),%xmm0                # z1
+# solve for ln(1+u)
+	movapd	%xmm2,%xmm1				# u
+	mulpd	%xmm2,%xmm2				# u^2
+	movapd	%xmm2,%xmm5
+	movapd	.L__real_cb3(%rip),%xmm3
+	mulpd	%xmm2,%xmm3				#Cu2
+	mulpd	%xmm1,%xmm5				# u^3
+	addpd	.L__real_cb2(%rip),%xmm3 #B+Cu2
+
+	mulpd	%xmm5,%xmm2				# u^5
+	movapd	.L__real_log2e_lead(%rip),%xmm4
+
+	mulpd	.L__real_cb1(%rip),%xmm5 #Au3
+	addpd	%xmm5,%xmm1				# u+Au3
+	movapd	%xmm0,%xmm5				#z1 copy
+	mulpd	%xmm3,%xmm2				# u5(B+Cu2)
+	movapd	.L__real_log2e_tail(%rip),%xmm3
+
+	movapd	p_xexp(%rsp),%xmm6		# xexp
+	addpd	%xmm2,%xmm1				# poly
+# recombine
+	lea		.L__np_ln_tail_table(%rip),%rdx
+        movlpd   -512(%rdx,%rax,8),%xmm2                #z2     +=q
+        movhpd   -512(%rdx,%rcx,8),%xmm2                #z2     +=q
+		lea		.L__np_ln_lead_table(%rip),%rdx
+		mov		p_idx2(%rsp),%eax
+		mov		p_idx2+4(%rsp),%ecx
+	addpd	%xmm2,%xmm1	#z2
+	movapd	%xmm1,%xmm2 #z2 copy
+
+
+	mulpd	%xmm4,%xmm5
+	mulpd	%xmm4,%xmm1
+		movapd	.L__real_half(%rip),%xmm4							# .5
+		subpd	%xmm9,%xmm8											# f2 = f - f1
+		mulpd	%xmm8,%xmm4
+		addpd	%xmm4,%xmm9
+	mulpd	%xmm3,%xmm2	#z2*log2e_tail
+	mulpd	%xmm3,%xmm0	#z1*log2e_tail
+	addpd	%xmm6,%xmm5	#r1 = z1*log2e_lead + xexp
+	addpd	%xmm2,%xmm0	#z1*log2e_tail + z2*log2e_tail
+	addpd	%xmm1,%xmm0				#r2
+
+
+		divpd	%xmm9,%xmm8				# u
+		movapd	p_x2(%rsp),%xmm3
+		andpd	.L__real_inf(%rip),%xmm3
+		cmppd	$0,.L__real_inf(%rip),%xmm3
+		movmskpd	%xmm3,%r10d
+		movapd	p_x2(%rsp),%xmm6
+		cmppd	$2,.L__real_zero(%rip),%xmm6
+		movmskpd	%xmm6,%r11d
+
+# check for nans/infs
+	test		$3,%r8d
+	addpd	%xmm5,%xmm0		#r1+r2
+	jnz		.L__log_naninf
+.L__vlog1:
+# check for negative numbers or zero
+	test		$3,%r9d
+	jnz		.L__z_or_n
+
+
+.L__vlog2:
+
+
+	# It seems like a good idea to try and interleave
+	# even more of the following code sooner into the
+	# program.  But there were conflicts with the table
+	# index registers, making the problem difficult.
+	# After a lot of work in a branch of this file,
+	# I was not able to match the speed of this version.
+	# CodeAnalyst shows that there is lots of unused add
+	# pipe time around the divides, but the processor
+	# doesn't seem to be able to schedule in those slots.
+
+	        movlpd   -512(%rdx,%rax,8),%xmm7                #z2     +=q
+        	movhpd   -512(%rdx,%rcx,8),%xmm7                #z2     +=q
+
+# check for near one
+	mov			p_n1(%rsp),%r9d
+	test			$3,%r9d
+	jnz			.L__near_one1
+.L__vlog2n:
+
+
+	# solve for ln(1+u)
+		movapd	%xmm8,%xmm9				# u
+		mulpd	%xmm8,%xmm8				# u^2
+		movapd	%xmm8,%xmm5
+		movapd	.L__real_cb3(%rip),%xmm3
+		mulpd	%xmm8,%xmm3				#Cu2
+		mulpd	%xmm9,%xmm5				# u^3
+		addpd	.L__real_cb2(%rip),%xmm3 		#B+Cu2
+
+		mulpd	%xmm5,%xmm8				# u^5
+		movapd	.L__real_log2e_lead(%rip),%xmm4
+
+		mulpd	.L__real_cb1(%rip),%xmm5 		#Au3
+		addpd	%xmm5,%xmm9				# u+Au3
+		movapd	%xmm7,%xmm5				#z1 copy
+		mulpd	%xmm3,%xmm8				# u5(B+Cu2)
+		movapd	.L__real_log2e_tail(%rip),%xmm3
+		movapd	p_xexp2(%rsp),%xmm6			# xexp
+		addpd	%xmm8,%xmm9				# poly
+	# recombine
+		lea		.L__np_ln_tail_table(%rip),%rdx
+	        movlpd   -512(%rdx,%rax,8),%xmm2                #z2     +=q
+        	movhpd   -512(%rdx,%rcx,8),%xmm2                #z2     +=q
+		addpd	%xmm2,%xmm9		#z2
+		movapd	%xmm9,%xmm2		#z2 copy
+
+		mulpd	%xmm4,%xmm5	#z1*log2e_lead
+		mulpd	%xmm4,%xmm9	#z2*log2e_lead
+		mulpd	%xmm3,%xmm2	#z2*log2e_tail
+		mulpd	%xmm3,%xmm7	#z1*log2e_tail
+		addpd	%xmm6,%xmm5	#r1 = z1*log2e_lead + xexp
+		addpd	%xmm2,%xmm7	#z1*log2e_tail + z2*log2e_tail
+
+
+		addpd	%xmm9,%xmm7				#r2
+
+	# check for nans/infs
+		test		$3,%r10d
+		addpd	%xmm5,%xmm7
+		jnz		.L__log_naninf2
+.L__vlog3:
+# check for negative numbers or zero
+		test		$3,%r11d
+		jnz		.L__z_or_n2
+
+.L__vlog4:
+
+
+	mov			p_n12(%rsp),%r9d
+	test			$3,%r9d
+	jnz			.L__near_one2
+
+.L__vlog4n:
+
+# store the result _m128d
+		movapd	%xmm7,%xmm1
+
+
+.L__finish:
+	mov		save_rbx(%rsp),%rbx		# restore rbx
+	add		$stack_size,%rsp
+	ret
+
+	.align	16
+.Lboth_nearone:
+# saves 10 cycles
+#      r = x - 1.0;
+	movapd	.L__real_two(%rip),%xmm2
+	subpd	.L__real_one(%rip),%xmm0	   # r
+#      u          = r / (2.0 + r);
+	addpd	%xmm0,%xmm2
+	movapd	%xmm0,%xmm1
+	divpd	%xmm2,%xmm1		# u
+	movapd	.L__real_ca4(%rip),%xmm4	  #D
+	movapd	.L__real_ca3(%rip),%xmm5	  #C
+#      correction = r * u;
+	movapd	%xmm0,%xmm6
+	mulpd	%xmm1,%xmm6		# correction
+#      u          = u + u;
+	addpd	%xmm1,%xmm1		#u
+	movapd	%xmm1,%xmm2
+	mulpd	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulpd	%xmm1,%xmm5		# Cu
+	movapd	%xmm1,%xmm3
+	mulpd	%xmm2,%xmm3		# u^3
+	mulpd	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulpd	%xmm3,%xmm4		#Du^3
+
+	addpd	.L__real_ca1(%rip),%xmm2	# +A
+	movapd	%xmm3,%xmm1
+	mulpd	%xmm1,%xmm1		# u^6
+	addpd	%xmm4,%xmm5		#Cu+Du3
+
+	mulpd	%xmm3,%xmm2		#u3(A+Bu2)
+	mulpd	%xmm5,%xmm1		#u6(Cu+Du3)
+	addpd	%xmm1,%xmm2
+	subpd	%xmm6,%xmm2		# -correction
+
+#	loge to log2
+	movapd 	%xmm0,%xmm3		#r1 = r
+	pand	.L__mask_lower(%rip),%xmm3
+	subpd	%xmm3,%xmm0
+	addpd 	%xmm0,%xmm2		#r2 = r2 + (r - r1);
+
+	movapd 	%xmm3,%xmm0
+	movapd	%xmm2,%xmm1
+
+	mulpd 	.L__real_log2e_tail(%rip),%xmm2
+	mulpd 	.L__real_log2e_tail(%rip),%xmm0
+	mulpd 	.L__real_log2e_lead(%rip),%xmm1
+	mulpd 	.L__real_log2e_lead(%rip),%xmm3
+	addpd 	%xmm2,%xmm0
+	addpd 	%xmm1,%xmm0
+	addpd	%xmm3,%xmm0
+
+#      return r + r2;
+#	addpd	%xmm2,%xmm0
+	ret
+
+	.align	16
+.L__near_one1:
+	cmp	$3,%r9d
+	jnz		.L__n1nb1
+
+	movapd	p_x(%rsp),%xmm0
+	call	.Lboth_nearone
+	jmp		.L__vlog2n
+
+	.align	16
+.L__n1nb1:
+	test	$1,%r9d
+	jz		.L__lnn12
+
+	movlpd	p_x(%rsp),%xmm0
+	call	.L__ln1
+
+.L__lnn12:
+	test	$2,%r9d		# second number?
+	jz		.L__lnn1e
+	movlpd	%xmm0,p_x(%rsp)
+	movlpd	p_x+8(%rsp),%xmm0
+	call	.L__ln1
+	movlpd	%xmm0,p_x+8(%rsp)
+	movapd	p_x(%rsp),%xmm0
+
+.L__lnn1e:
+	jmp		.L__vlog2n
+
+
+	.align	16
+.L__near_one2:
+	cmp	$3,%r9d
+	jnz		.L__n1nb2
+
+	movapd	%xmm0,%xmm8
+	movapd	p_x2(%rsp),%xmm0
+	call	.Lboth_nearone
+	movapd	%xmm0,%xmm7
+	movapd	%xmm8,%xmm0
+	jmp		.L__vlog4n
+
+	.align	16
+.L__n1nb2:
+	movapd	%xmm0,%xmm8
+	test	$1,%r9d
+	jz		.L__lnn22
+
+	movapd	%xmm7,%xmm0
+	movlpd	p_x2(%rsp),%xmm0
+	call	.L__ln1
+	movapd	%xmm0,%xmm7
+
+.L__lnn22:
+	test	$2,%r9d		# second number?
+	jz		.L__lnn2e
+	movlpd	%xmm7,p_x2(%rsp)
+	movlpd	p_x2+8(%rsp),%xmm0
+	call	.L__ln1
+	movlpd	%xmm0,p_x2+8(%rsp)
+	movapd	p_x2(%rsp),%xmm7
+
+.L__lnn2e:
+	movapd	%xmm8,%xmm0
+	jmp		.L__vlog4n
+
+	.align	16
+
+.L__ln1:
+# saves 10 cycles
+#      r = x - 1.0;
+	movlpd	.L__real_two(%rip),%xmm2
+	subsd	.L__real_one(%rip),%xmm0	   # r
+#      u          = r / (2.0 + r);
+	addsd	%xmm0,%xmm2
+	movsd	%xmm0,%xmm1
+	divsd	%xmm2,%xmm1		# u
+	movlpd	.L__real_ca4(%rip),%xmm4	  #D
+	movlpd	.L__real_ca3(%rip),%xmm5	  #C
+#      correction = r * u;
+	movsd	%xmm0,%xmm6
+	mulsd	%xmm1,%xmm6		# correction
+#      u          = u + u;
+	addsd	%xmm1,%xmm1		#u
+	movsd	%xmm1,%xmm2
+	mulsd	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulsd	%xmm1,%xmm5		# Cu
+	movsd	%xmm1,%xmm3
+	mulsd	%xmm2,%xmm3		# u^3
+	mulsd	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulsd	%xmm3,%xmm4		#Du^3
+
+	addsd	.L__real_ca1(%rip),%xmm2	# +A
+	movsd	%xmm3,%xmm1
+	mulsd	%xmm1,%xmm1		# u^6
+	addsd	%xmm4,%xmm5		#Cu+Du3
+
+	mulsd	%xmm3,%xmm2		#u3(A+Bu2)
+	mulsd	%xmm5,%xmm1		#u6(Cu+Du3)
+	addsd	%xmm1,%xmm2
+	subsd	%xmm6,%xmm2		# -correction
+
+
+#	loge to log2
+	movsd 	%xmm0,%xmm3		#r1 = r
+	pand	.L__mask_lower(%rip),%xmm3
+	subsd	%xmm3,%xmm0
+	addsd 	%xmm0,%xmm2		#r2 = r2 + (r - r1);
+
+	movsd 	%xmm3,%xmm0
+	movsd	%xmm2,%xmm1
+
+	mulsd 	.L__real_log2e_tail(%rip),%xmm2
+	mulsd 	.L__real_log2e_tail(%rip),%xmm0
+	mulsd 	.L__real_log2e_lead(%rip),%xmm1
+	mulsd 	.L__real_log2e_lead(%rip),%xmm3
+	addsd 	%xmm2,%xmm0
+	addsd 	%xmm1,%xmm0
+	addsd	%xmm3,%xmm0
+
+#      return r + r2;
+#	addsd	%xmm2,%xmm0
+	ret
+
+	.align	16
+
+# at least one of the numbers was a nan or infinity
+.L__log_naninf:
+	test		$1,%r8d		# first number?
+	jz		.L__lninf2
+
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x(%rsp),%rdx
+	movlpd	p_x(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$2,%xmm1,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__lninf2:
+	test		$2,%r8d		# second number?
+	jz		.L__lninfe
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x+8(%rsp),%rdx
+	movlpd	p_x+8(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$0,%xmm0,%xmm1
+	movapd	%xmm1,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__lninfe:
+	jmp		.L__vlog1		# continue processing if not
+
+# at least one of the numbers was a nan or infinity
+.L__log_naninf2:
+	movapd	%xmm0,%xmm2
+	test		$1,%r10d		# first number?
+	jz		.L__lninf22
+
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm7,%xmm1		# save the inputs
+	mov		p_x2(%rsp),%rdx
+	movlpd	p_x2(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$2,%xmm7,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+	movapd	%xmm0,%xmm7
+
+.L__lninf22:
+	test		$2,%r10d		# second number?
+	jz		.L__lninfe2
+
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	mov		p_x2+8(%rsp),%rdx
+	movlpd	p_x2+8(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$0,%xmm0,%xmm7
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__lninfe2:
+	movapd	%xmm2,%xmm0
+	jmp		.L__vlog3		# continue processing if not
+
+# a subroutine to treat one number for nan/infinity
+# the number is expected in rdx and returned in the low
+# half of xmm0
+.L__lni:
+	mov		$0x0000FFFFFFFFFFFFF,%rax
+	test	%rax,%rdx
+	jnz		.L__lnan					# jump if mantissa not zero, so it's a NaN
+# inf
+	rcl		$1,%rdx
+	jnc		.L__lne2					# log(+inf) = inf
+# negative x
+	movlpd	.L__real_nan(%rip),%xmm0
+	ret
+
+#NaN
+.L__lnan:
+	mov		$0x00008000000000000,%rax	# convert to quiet
+	or		%rax,%rdx
+.L__lne:
+	movd	%rdx,%xmm0
+.L__lne2:
+	ret
+
+	.align	16
+
+# at least one of the numbers was a zero, a negative number, or both.
+.L__z_or_n:
+	test		$1,%r9d		# first number?
+	jz		.L__zn2
+
+	mov		%rax,p2_temp(%rsp)
+ 	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x(%rsp),%rax
+	call	.L__zni
+	shufpd	$2,%xmm1,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__zn2:
+	test		$2,%r9d		# second number?
+	jz		.L__zne
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x+8(%rsp),%rax
+	call	.L__zni
+	shufpd	$0,%xmm0,%xmm1
+	movapd	%xmm1,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__zne:
+	jmp		.L__vlog2
+
+.L__z_or_n2:
+	movapd	%xmm0,%xmm2
+	test		$1,%r11d		# first number?
+	jz		.L__zn22
+
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	mov		p_x2(%rsp),%rax
+	call	.L__zni
+	shufpd	$2,%xmm7,%xmm0
+	movapd	%xmm0,%xmm7
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__zn22:
+	test		$2,%r11d		# second number?
+	jz		.L__zne2
+
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	mov		p_x2+8(%rsp),%rax
+	call	.L__zni
+	shufpd	$0,%xmm0,%xmm7
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__zne2:
+	movapd	%xmm2,%xmm0
+	jmp		.L__vlog4
+# a subroutine to treat one number for zero or negative values
+# the number is expected in rax and returned in the low
+# half of xmm0
+.L__zni:
+	shl		$1,%rax
+	jnz		.L__zn_x		 ## if just a carry, then must be negative
+	movlpd	.L__real_ninf(%rip),%xmm0  # C99 specs -inf for +-0
+	ret
+.L__zn_x:
+	movlpd	.L__real_nan(%rip),%xmm0
+	ret
+
+
+
+	.data
+	.align	16
+
+.L__real_one:				.quad 0x03ff0000000000000	# 1.0
+						.quad 0x03ff0000000000000					# for alignment
+.L__real_two:				.quad 0x04000000000000000	# 1.0
+						.quad 0x04000000000000000
+.L__real_ninf:				.quad 0x0fff0000000000000	# -inf
+						.quad 0x0fff0000000000000
+.L__real_inf:				.quad 0x07ff0000000000000	# +inf
+						.quad 0x07ff0000000000000
+.L__real_nan:				.quad 0x07ff8000000000000	# NaN
+						.quad 0x07ff8000000000000
+
+.L__real_zero:				.quad 0x00000000000000000	# 0.0
+						.quad 0x00000000000000000
+
+.L__real_sign:				.quad 0x08000000000000000	# sign bit
+						.quad 0x08000000000000000
+.L__real_notsign:			.quad 0x07ffFFFFFFFFFFFFF	# ^sign bit
+						.quad 0x07ffFFFFFFFFFFFFF
+.L__real_threshold:		.quad 0x03F9EB85000000000	# .03
+						.quad 0x03F9EB85000000000
+.L__real_qnanbit:			.quad 0x00008000000000000	# quiet nan bit
+						.quad 0x00008000000000000
+.L__real_mant:				.quad 0x0000FFFFFFFFFFFFF	# mantissa bits
+						.quad 0x0000FFFFFFFFFFFFF
+.L__real_3f80000000000000:	.quad 0x03f80000000000000	# /* 0.0078125 = 1/128 */
+						.quad 0x03f80000000000000
+.L__mask_1023:				.quad 0x000000000000003ff	#
+						.quad 0x000000000000003ff
+.L__mask_040:				.quad 0x00000000000000040	#
+						.quad 0x00000000000000040
+.L__mask_001:				.quad 0x00000000000000001	#
+						.quad 0x00000000000000001
+
+.L__real_ca1:				.quad 0x03fb55555555554e6	# 8.33333333333317923934e-02
+						.quad 0x03fb55555555554e6
+.L__real_ca2:				.quad 0x03f89999999bac6d4	# 1.25000000037717509602e-02
+						.quad 0x03f89999999bac6d4
+.L__real_ca3:				.quad 0x03f62492307f1519f	# 2.23213998791944806202e-03
+						.quad 0x03f62492307f1519f
+.L__real_ca4:				.quad 0x03f3c8034c85dfff0	# 4.34887777707614552256e-04
+						.quad 0x03f3c8034c85dfff0
+
+
+.L__real_cb1:				.quad 0x03fb5555555555557	# 8.33333333333333593622e-02
+						.quad 0x03fb5555555555557
+.L__real_cb2:				.quad 0x03f89999999865ede	# 1.24999999978138668903e-02
+						.quad 0x03f89999999865ede
+.L__real_cb3:				.quad 0x03f6249423bd94741	# 2.23219810758559851206e-03
+						.quad 0x03f6249423bd94741
+.L__real_log2_lead:  		.quad 0x03fe62e42e0000000	# log2_lead	  6.93147122859954833984e-01
+						.quad 0x03fe62e42e0000000
+.L__real_log2_tail: 		.quad 0x03e6efa39ef35793c	# log2_tail	  5.76999904754328540596e-08
+						.quad 0x03e6efa39ef35793c
+
+.L__real_half:				.quad 0x03fe0000000000000	# 1/2
+						.quad 0x03fe0000000000000
+.L__real_log2e_lead:		.quad 0x03FF7154400000000	# log2e_lead	  1.44269180297851562500E+00
+						.quad 0x03FF7154400000000
+.L__real_log2e_tail :		.quad 0x03ECB295C17F0BBBE	# log2e_tail	  3.23791044778235969970E-06
+						.quad 0x03ECB295C17F0BBBE
+.L__mask_lower:			.quad 0x0ffffffff00000000
+						.quad 0x0ffffffff00000000
+	.align	16
+
+.L__np_ln_lead_table:
+	.quad	0x0000000000000000 		# 0.00000000000000000000e+00
+	.quad	0x3f8fc0a800000000		# 1.55041813850402832031e-02
+	.quad	0x3f9f829800000000		# 3.07716131210327148438e-02
+	.quad	0x3fa7745800000000		# 4.58095073699951171875e-02
+	.quad	0x3faf0a3000000000		# 6.06245994567871093750e-02
+	.quad	0x3fb341d700000000		# 7.52233862876892089844e-02
+	.quad	0x3fb6f0d200000000		# 8.96121263504028320312e-02
+	.quad	0x3fba926d00000000		# 1.03796780109405517578e-01
+	.quad	0x3fbe270700000000		# 1.17783010005950927734e-01
+	.quad	0x3fc0d77e00000000		# 1.31576299667358398438e-01
+	.quad	0x3fc2955280000000		# 1.45181953907012939453e-01
+	.quad	0x3fc44d2b00000000		# 1.58604979515075683594e-01
+	.quad	0x3fc5ff3000000000		# 1.71850204467773437500e-01
+	.quad	0x3fc7ab8900000000		# 1.84922337532043457031e-01
+	.quad	0x3fc9525a80000000		# 1.97825729846954345703e-01
+	.quad	0x3fcaf3c900000000		# 2.10564732551574707031e-01
+	.quad	0x3fcc8ff780000000		# 2.23143517971038818359e-01
+	.quad	0x3fce270700000000		# 2.35566020011901855469e-01
+	.quad	0x3fcfb91800000000		# 2.47836112976074218750e-01
+	.quad	0x3fd0a324c0000000		# 2.59957492351531982422e-01
+	.quad	0x3fd1675c80000000		# 2.71933674812316894531e-01
+	.quad	0x3fd22941c0000000		# 2.83768117427825927734e-01
+	.quad	0x3fd2e8e280000000		# 2.95464158058166503906e-01
+	.quad	0x3fd3a64c40000000		# 3.07025015354156494141e-01
+	.quad	0x3fd4618bc0000000		# 3.18453729152679443359e-01
+	.quad	0x3fd51aad80000000		# 3.29753279685974121094e-01
+	.quad	0x3fd5d1bd80000000		# 3.40926527976989746094e-01
+	.quad	0x3fd686c800000000		# 3.51976394653320312500e-01
+	.quad	0x3fd739d7c0000000		# 3.62905442714691162109e-01
+	.quad	0x3fd7eaf800000000		# 3.73716354370117187500e-01
+	.quad	0x3fd89a3380000000		# 3.84411692619323730469e-01
+	.quad	0x3fd9479400000000		# 3.94993782043457031250e-01
+	.quad	0x3fd9f323c0000000		# 4.05465066432952880859e-01
+	.quad	0x3fda9cec80000000		# 4.15827870368957519531e-01
+	.quad	0x3fdb44f740000000		# 4.26084339618682861328e-01
+	.quad	0x3fdbeb4d80000000		# 4.36236739158630371094e-01
+	.quad	0x3fdc8ff7c0000000		# 4.46287095546722412109e-01
+	.quad	0x3fdd32fe40000000		# 4.56237375736236572266e-01
+	.quad	0x3fddd46a00000000		# 4.66089725494384765625e-01
+	.quad	0x3fde744240000000		# 4.75845873355865478516e-01
+	.quad	0x3fdf128f40000000		# 4.85507786273956298828e-01
+	.quad	0x3fdfaf5880000000		# 4.95077252388000488281e-01
+	.quad	0x3fe02552a0000000		# 5.04556000232696533203e-01
+	.quad	0x3fe0723e40000000		# 5.13945698738098144531e-01
+	.quad	0x3fe0be72e0000000		# 5.23248136043548583984e-01
+	.quad	0x3fe109f380000000		# 5.32464742660522460938e-01
+	.quad	0x3fe154c3c0000000		# 5.41597247123718261719e-01
+	.quad	0x3fe19ee6a0000000		# 5.50647079944610595703e-01
+	.quad	0x3fe1e85f40000000		# 5.59615731239318847656e-01
+	.quad	0x3fe23130c0000000		# 5.68504691123962402344e-01
+	.quad	0x3fe2795e00000000		# 5.77315330505371093750e-01
+	.quad	0x3fe2c0e9e0000000		# 5.86049020290374755859e-01
+	.quad	0x3fe307d720000000		# 5.94707071781158447266e-01
+	.quad	0x3fe34e2880000000		# 6.03290796279907226562e-01
+	.quad	0x3fe393e0c0000000		# 6.11801505088806152344e-01
+	.quad	0x3fe3d90260000000		# 6.20240390300750732422e-01
+	.quad	0x3fe41d8fe0000000		# 6.28608644008636474609e-01
+	.quad	0x3fe4618bc0000000		# 6.36907458305358886719e-01
+	.quad	0x3fe4a4f840000000		# 6.45137906074523925781e-01
+	.quad	0x3fe4e7d800000000		# 6.53301239013671875000e-01
+	.quad	0x3fe52a2d20000000		# 6.61398470401763916016e-01
+	.quad	0x3fe56bf9c0000000		# 6.69430613517761230469e-01
+	.quad	0x3fe5ad4040000000		# 6.77398800849914550781e-01
+	.quad	0x3fe5ee02a0000000		# 6.85303986072540283203e-01
+	.quad	0x3fe62e42e0000000		# 6.93147122859954833984e-01
+	.quad 0					# for alignment
+
+.L__np_ln_tail_table:
+	.quad	0x00000000000000000 # 0	; 0.00000000000000000000e+00
+	.quad	0x03e361f807c79f3db		# 5.15092497094772879206e-09
+	.quad	0x03e6873c1980267c8		# 4.55457209735272790188e-08
+	.quad	0x03e5ec65b9f88c69e		# 2.86612990859791781788e-08
+	.quad	0x03e58022c54cc2f99		# 2.23596477332056055352e-08
+	.quad	0x03e62c37a3a125330		# 3.49498983167142274770e-08
+	.quad	0x03e615cad69737c93		# 3.23392843005887000414e-08
+	.quad	0x03e4d256ab1b285e9		# 1.35722380472479366661e-08
+	.quad	0x03e5b8abcb97a7aa2		# 2.56504325268044191098e-08
+	.quad	0x03e6f34239659a5dc		# 5.81213608741512136843e-08
+	.quad	0x03e6e07fd48d30177		# 5.59374849578288093334e-08
+	.quad	0x03e6b32df4799f4f6		# 5.06615629004996189970e-08
+	.quad	0x03e6c29e4f4f21cf8		# 5.24588857848400955725e-08
+	.quad	0x03e1086c848df1b59		# 9.61968535632653505972e-10
+	.quad	0x03e4cf456b4764130		# 1.34829655346594463137e-08
+	.quad	0x03e63a02ffcb63398		# 3.65557749306383026498e-08
+	.quad	0x03e61e6a6886b0976		# 3.33431709374069198903e-08
+	.quad	0x03e6b8abcb97a7aa2		# 5.13008650536088382197e-08
+	.quad	0x03e6b578f8aa35552		# 5.09285070380306053751e-08
+	.quad	0x03e6139c871afb9fc		# 3.20853940845502057341e-08
+	.quad	0x03e65d5d30701ce64		# 4.06713248643004200446e-08
+	.quad	0x03e6de7bcb2d12142		# 5.57028186706125221168e-08
+	.quad	0x03e6d708e984e1664		# 5.48356693724804282546e-08
+	.quad	0x03e556945e9c72f36		# 1.99407553679345001938e-08
+	.quad	0x03e20e2f613e85bda		# 1.96585517245087232086e-09
+	.quad	0x03e3cb7e0b42724f6		# 6.68649386072067321503e-09
+	.quad	0x03e6fac04e52846c7		# 5.89936034642113390002e-08
+	.quad	0x03e5e9b14aec442be		# 2.85038578721554472484e-08
+	.quad	0x03e6b5de8034e7126		# 5.09746772910284482606e-08
+	.quad	0x03e6dc157e1b259d3		# 5.54234668933210171467e-08
+	.quad	0x03e3b05096ad69c62		# 6.29100830926604004874e-09
+	.quad	0x03e5c2116faba4cdd		# 2.61974119468563937716e-08
+	.quad	0x03e665fcc25f95b47		# 4.16752115011186398935e-08
+	.quad	0x03e5a9a08498d4850		# 2.47747534460820790327e-08
+	.quad	0x03e6de647b1465f77		# 5.56922172017964209793e-08
+	.quad	0x03e5da71b7bf7861d		# 2.76162876992552906035e-08
+	.quad	0x03e3e6a6886b09760		# 7.08169709942321478061e-09
+	.quad	0x03e6f0075eab0ef64		# 5.77453510221151779025e-08
+	.quad	0x03e33071282fb989b		# 4.43021445893361960146e-09
+	.quad	0x03e60eb43c3f1bed2		# 3.15140984357495864573e-08
+	.quad	0x03e5faf06ecb35c84		# 2.95077445089736670973e-08
+	.quad	0x03e4ef1e63db35f68		# 1.44098510263167149349e-08
+	.quad	0x03e469743fb1a71a5		# 1.05196987538551827693e-08
+	.quad	0x03e6c1cdf404e5796		# 5.23641361722697546261e-08
+	.quad	0x03e4094aa0ada625e		# 7.72099925253243069458e-09
+	.quad	0x03e6e2d4c96fde3ec		# 5.62089493829364197156e-08
+	.quad	0x03e62f4d5e9a98f34		# 3.53090261098577946927e-08
+	.quad	0x03e6467c96ecc5cbe		# 3.80080516835568242269e-08
+	.quad	0x03e6e7040d03dec5a		# 5.66961038386146408282e-08
+	.quad	0x03e67bebf4282de36		# 4.42287063097349852717e-08
+	.quad	0x03e6289b11aeb783f		# 3.45294525105681104660e-08
+	.quad	0x03e5a891d1772f538		# 2.47132034530447431509e-08
+	.quad	0x03e634f10be1fb591		# 3.59655343422487209774e-08
+	.quad	0x03e6d9ce1d316eb93		# 5.51581770357780862071e-08
+	.quad	0x03e63562a19a9c442		# 3.60171867511861372793e-08
+	.quad	0x03e54e2adf548084c		# 1.94511067964296180547e-08
+	.quad	0x03e508ce55cc8c97a		# 1.54137376631349347838e-08
+	.quad	0x03e30e2f613e85bda		# 3.93171034490174464173e-09
+	.quad	0x03e6db03ebb0227bf		# 5.52990607758839766440e-08
+	.quad	0x03e61b75bb09cb098		# 3.29990737637586136511e-08
+	.quad	0x03e496f16abb9df22		# 1.18436010922446096216e-08
+	.quad	0x03e65b3f399411c62		# 4.04248680368301346709e-08
+	.quad	0x03e586b3e59f65355		# 2.27418915900284316293e-08
+	.quad	0x03e52482ceae1ac12		# 1.70263791333409206020e-08
+	.quad	0x03e6efa39ef35793c		# 5.76999904754328540596e-08
+	.quad 0					# for alignment
+
diff --git a/src/gas/vrd4sin.S b/src/gas/vrd4sin.S
new file mode 100644
index 0000000..b611dfd
--- /dev/null
+++ b/src/gas/vrd4sin.S
@@ -0,0 +1,2915 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+# vrd4sin.s
+#
+# A vector implementation of the sin libm function.
+#
+# Prototype:
+#
+#    __m128d,__m128d __vrd4_sin(__m128d x1, __m128d x2);
+#
+# Computes Sine of x for an array of input values.
+# Places the results into the supplied y array.
+# Does not perform error checking.
+# Denormal inputs may produce unexpected results.
+# This routine computes 4 double precision Sine values at a time.
+# The four values are passed as packed doubles in xmm0 and xmm1.
+# The four results are returned as packed doubles in xmm0 and xmm1.
+# Note that this represents a non-standard ABI usage, as no ABI
+# ( and indeed C) currently allows returning 2 values for a function.
+# It is expected that some compilers may be able to take advantage of this
+# interface when implementing vectorized loops.  Using the array implementation
+# of the routine requires putting the inputs into memory, and retrieving
+# the results from memory.  This routine eliminates the need for this
+# overhead if the data does not already reside in memory.
+# This routine is derived directly from the array version.
+# Author: Harsha Jagasia
+# Email:  harsha.jagasia@amd.com
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.data
+.align 16
+.L__real_7fffffffffffffff: 	.quad 0x07fffffffffffffff	#Sign bit zero
+				.quad 0x07fffffffffffffff
+.L__real_3ff0000000000000: 	.quad 0x03ff0000000000000	# 1.0
+				.quad 0x03ff0000000000000
+.L__real_v2p__27:		.quad 0x03e40000000000000	# 2p-27
+				.quad 0x03e40000000000000
+.L__real_3fe0000000000000: 	.quad 0x03fe0000000000000	# 0.5
+				.quad 0x03fe0000000000000
+.L__real_3fc5555555555555: 	.quad 0x03fc5555555555555	# 0.166666666666
+				.quad 0x03fc5555555555555
+.L__real_3fe45f306dc9c883: 	.quad 0x03fe45f306dc9c883	# twobypi
+				.quad 0x03fe45f306dc9c883
+.L__real_3ff921fb54400000: 	.quad 0x03ff921fb54400000	# piby2_1
+				.quad 0x03ff921fb54400000
+.L__real_3dd0b4611a626331: 	.quad 0x03dd0b4611a626331	# piby2_1tail
+				.quad 0x03dd0b4611a626331
+.L__real_3dd0b4611a600000: 	.quad 0x03dd0b4611a600000	# piby2_2
+				.quad 0x03dd0b4611a600000
+.L__real_3ba3198a2e037073: 	.quad 0x03ba3198a2e037073	# piby2_2tail
+				.quad 0x03ba3198a2e037073
+.L__real_fffffffff8000000: 	.quad 0x0fffffffff8000000	# mask for stripping head and tail
+				.quad 0x0fffffffff8000000
+.L__real_8000000000000000:	.quad 0x08000000000000000	# -0  or signbit
+				.quad 0x08000000000000000
+.L__reald_one_one:		.quad 0x00000000100000001	#
+				.quad 0
+.L__reald_two_two:		.quad 0x00000000200000002	#
+				.quad 0
+.L__reald_one_zero:		.quad 0x00000000100000000	# sin_cos_filter
+				.quad 0
+.L__reald_zero_one:		.quad 0x00000000000000001	#
+				.quad 0
+.L__reald_two_zero:		.quad 0x00000000200000000	#
+				.quad 0
+.L__realq_one_one:		.quad 0x00000000000000001	#
+				.quad 0x00000000000000001	#
+.L__realq_two_two:		.quad 0x00000000000000002	#
+				.quad 0x00000000000000002	#
+.L__real_1_x_mask:		.quad 0x0ffffffffffffffff	#
+				.quad 0x03ff0000000000000	#
+.L__real_zero:			.quad 0x00000000000000000	#
+				.quad 0x00000000000000000	#
+.L__real_one:			.quad 0x00000000000000001	#
+				.quad 0x00000000000000001	#
+.Lcosarray:
+	.quad	0x03fa5555555555555		# 0.0416667		   	c1
+	.quad	0x03fa5555555555555
+	.quad	0x0bf56c16c16c16967		# -0.00138889	   		c2
+	.quad	0x0bf56c16c16c16967
+	.quad	0x03efa01a019f4ec90		# 2.48016e-005			c3
+	.quad	0x03efa01a019f4ec90
+	.quad	0x0be927e4fa17f65f6		# -2.75573e-007			c4
+	.quad	0x0be927e4fa17f65f6
+	.quad	0x03e21eeb69037ab78		# 2.08761e-009			c5
+	.quad	0x03e21eeb69037ab78
+	.quad	0x0bda907db46cc5e42		# -1.13826e-011	   		c6
+	.quad	0x0bda907db46cc5e42
+.Lsinarray:
+	.quad	0x0bfc5555555555555		# -0.166667	   		s1
+	.quad	0x0bfc5555555555555
+	.quad	0x03f81111111110bb3		# 0.00833333	   		s2
+	.quad	0x03f81111111110bb3
+	.quad	0x0bf2a01a019e83e5c		# -0.000198413			s3
+	.quad	0x0bf2a01a019e83e5c
+	.quad	0x03ec71de3796cde01		# 2.75573e-006			s4
+	.quad	0x03ec71de3796cde01
+	.quad	0x0be5ae600b42fdfa7		# -2.50511e-008			s5
+	.quad	0x0be5ae600b42fdfa7
+	.quad	0x03de5e0b2f9a43bb8		# 1.59181e-010	   		s6
+	.quad	0x03de5e0b2f9a43bb8
+.Lsincosarray:
+	.quad	0x0bfc5555555555555		# -0.166667	   		s1
+	.quad	0x03fa5555555555555		# 0.0416667		   	c1
+	.quad	0x03f81111111110bb3		# 0.00833333	   		s2
+	.quad	0x0bf56c16c16c16967
+	.quad	0x0bf2a01a019e83e5c		# -0.000198413			s3
+	.quad	0x03efa01a019f4ec90
+	.quad	0x03ec71de3796cde01		# 2.75573e-006			s4
+	.quad	0x0be927e4fa17f65f6
+	.quad	0x0be5ae600b42fdfa7		# -2.50511e-008			s5
+	.quad	0x03e21eeb69037ab78
+	.quad	0x03de5e0b2f9a43bb8		# 1.59181e-010	   		s6
+	.quad	0x0bda907db46cc5e42
+.Lcossinarray:
+	.quad	0x03fa5555555555555		# 0.0416667		   	c1
+	.quad	0x0bfc5555555555555		# -0.166667	   		s1
+	.quad	0x0bf56c16c16c16967
+	.quad	0x03f81111111110bb3		# 0.00833333	   		s2
+	.quad	0x03efa01a019f4ec90
+	.quad	0x0bf2a01a019e83e5c		# -0.000198413			s3
+	.quad	0x0be927e4fa17f65f6
+	.quad	0x03ec71de3796cde01		# 2.75573e-006			s4
+	.quad	0x03e21eeb69037ab78
+	.quad	0x0be5ae600b42fdfa7		# -2.50511e-008			s5
+	.quad	0x0bda907db46cc5e42
+	.quad	0x03de5e0b2f9a43bb8		# 1.59181e-010	   		s6
+
+.Levensin_oddcos_tbl:
+		.quad	.Lsinsin_sinsin_piby4		# 0
+		.quad	.Lsinsin_sincos_piby4		# 1
+		.quad	.Lsinsin_cossin_piby4		# 2
+		.quad	.Lsinsin_coscos_piby4		# 3
+
+		.quad	.Lsincos_sinsin_piby4		# 4
+		.quad	.Lsincos_sincos_piby4		# 5
+		.quad	.Lsincos_cossin_piby4		# 6
+		.quad	.Lsincos_coscos_piby4		# 7
+
+		.quad	.Lcossin_sinsin_piby4		# 8
+		.quad	.Lcossin_sincos_piby4		# 9
+		.quad	.Lcossin_cossin_piby4		# 10
+		.quad	.Lcossin_coscos_piby4		# 11
+
+		.quad	.Lcoscos_sinsin_piby4		# 12
+		.quad	.Lcoscos_sincos_piby4		# 13
+		.quad	.Lcoscos_cossin_piby4		# 14
+		.quad	.Lcoscos_coscos_piby4		# 15
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    .text
+    .align 16
+    .p2align 4,,15
+
+# define local variable storage offsets
+.equ	p_temp,		0x00		# temporary for get/put bits operation
+.equ	p_temp1,	0x10		# temporary for get/put bits operation
+
+.equ	save_xmm6,	0x20		# temporary for get/put bits operation
+.equ	save_xmm7,	0x30		# temporary for get/put bits operation
+.equ	save_xmm8,	0x40		# temporary for get/put bits operation
+.equ	save_xmm9,	0x50		# temporary for get/put bits operation
+.equ	save_xmm10,	0x60		# temporary for get/put bits operation
+.equ	save_xmm11,	0x70		# temporary for get/put bits operation
+.equ	save_xmm12,	0x80		# temporary for get/put bits operation
+.equ	save_xmm13,	0x90		# temporary for get/put bits operation
+.equ	save_xmm14,	0x0A0		# temporary for get/put bits operation
+.equ	save_xmm15,	0x0B0		# temporary for get/put bits operation
+
+.equ	r,		0x0C0		# pointer to r for remainder_piby2
+.equ	rr,		0x0D0		# pointer to r for remainder_piby2
+.equ	region,		0x0E0		# pointer to r for remainder_piby2
+
+.equ	r1,		0x0F0		# pointer to r for remainder_piby2
+.equ	rr1,		0x0100		# pointer to r for remainder_piby2
+.equ	region1,	0x0110		# pointer to r for remainder_piby2
+
+.equ	p_temp2,	0x0120		# temporary for get/put bits operation
+.equ	p_temp3,	0x0130		# temporary for get/put bits operation
+
+.equ	p_temp4,	0x0140		# temporary for get/put bits operation
+.equ	p_temp5,	0x0150		# temporary for get/put bits operation
+
+.equ	p_original,	0x0160		# original x
+.equ	p_mask,		0x0170		# original x
+.equ	p_sign,		0x0180		# original x
+
+.equ	p_original1,	0x0190		# original x
+.equ	p_mask1,	0x01A0		# original x
+.equ	p_sign1,	0x01B0		# original x
+
+.equ	save_r12,	0x01C0		# temporary for get/put bits operation
+.equ	save_r13,	0x01D0		# temporary for get/put bits operation
+
+.globl __vrd4_sin
+    .type   __vrd4_sin,@function
+__vrd4_sin:
+
+	sub		$0x1E8,%rsp
+	mov		%r12,save_r12(%rsp)	# save r12
+	mov		%r13,save_r13(%rsp)	# save r13
+
+#DEBUG
+#	jmp 	.Lfinal_check
+#DEBUG
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#STARTMAIN
+
+movdqa	%xmm0,%xmm6
+movdqa	%xmm1,%xmm7
+movapd	.L__real_7fffffffffffffff(%rip),%xmm2
+
+andpd 	%xmm2,%xmm0				#Unsign
+andpd 	%xmm2,%xmm1				#Unsign
+
+movd	%xmm0,%rax				#rax is lower arg
+movhpd	%xmm0, p_temp+8(%rsp)
+mov    	p_temp+8(%rsp),%rcx			#rcx = upper arg
+movd	%xmm1,%r8				#r8 is lower arg
+movhpd	%xmm1, p_temp1+8(%rsp)
+mov    	p_temp1+8(%rsp),%r9			#r9 = upper arg
+
+movdqa	%xmm0,%xmm12
+movdqa	%xmm1,%xmm13
+
+pcmpgtd		%xmm6,%xmm12
+pcmpgtd		%xmm7,%xmm13
+movdqa		%xmm12,%xmm6
+movdqa		%xmm13,%xmm7
+psrldq		$4,%xmm12
+psrldq		$4,%xmm13
+psrldq		$8,%xmm6
+psrldq		$8,%xmm7
+
+mov 	$0x3FE921FB54442D18,%rdx			#piby4	+
+mov	$0x411E848000000000,%r10			#5e5	+
+movapd	.L__real_3fe0000000000000(%rip),%xmm4		#0.5 for later use	+
+
+por	%xmm6,%xmm12
+por	%xmm7,%xmm13
+movd	%xmm12,%r12				#Move Sign to gpr **
+movd	%xmm13,%r13				#Move Sign to gpr **
+
+movapd	%xmm0,%xmm2				#x0
+movapd	%xmm1,%xmm3				#x1
+movapd	%xmm0,%xmm6				#x0
+movapd	%xmm1,%xmm7				#x1
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm2 = x, xmm4 =0.5/t, xmm6 =x
+# xmm3 = x, xmm5 =0.5/t, xmm7 =x
+.align 16
+.Leither_or_both_arg_gt_than_piby4:
+	cmp	%r10,%rax
+	jae	.Lfirst_or_next3_arg_gt_5e5
+
+	cmp	%r10,%rcx
+	jae	.Lsecond_or_next2_arg_gt_5e5
+
+	cmp	%r10,%r8
+	jae	.Lthird_or_fourth_arg_gt_5e5
+
+	cmp	%r10,%r9
+	jae	.Lfourth_arg_gt_5e5
+
+
+#      /* Find out what multiple of piby2 */
+#        npi2  = (int)(x * twobypi + 0.5);
+	movapd	.L__real_3fe45f306dc9c883(%rip),%xmm0
+	mulpd	%xmm0,%xmm2						# * twobypi
+	mulpd	%xmm0,%xmm3						# * twobypi
+
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	addpd	%xmm4,%xmm3						# +0.5, npi2
+
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm0		# piby2_1
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm1		# piby2_1
+
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	cvttpd2dq	%xmm3,%xmm5					# convert packed double to packed integers
+
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm9		# piby2_2
+
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+	cvtdq2pd	%xmm5,%xmm3					# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+
+	movd	%xmm4,%r8						# Region
+	movd	%xmm5,%r9						# Region
+
+	mov 	.L__reald_one_zero(%rip),%rdx			#compare value for cossin path
+	mov	%r8,%r10
+	mov	%r9,%r11
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm0						# npi2 * piby2_1;
+       mulpd	%xmm3,%xmm1						# npi2 * piby2_1;
+
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+       mulpd	%xmm3,%xmm9						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm0,%xmm6						# rhead  = x - npi2 * piby2_1;
+       subpd	%xmm1,%xmm7						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm0						# t
+       movapd	%xmm7,%xmm1						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm0						# rhead
+       subpd	%xmm9,%xmm1						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm3		# npi2 * piby2_2tail
+
+       subpd	%xmm0,%xmm6						# t-rhead
+       subpd	%xmm1,%xmm7						# t-rhead
+
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       subpd	%xmm7,%xmm9						# - ((t - rhead) - rtail)
+
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       addpd	%xmm3,%xmm9						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm4  = npi2 (int), xmm0 =rhead, xmm8 =rtail
+# xmm5  = npi2 (int), xmm1 =rhead, xmm9 =rtail
+
+	and	.L__reald_one_one(%rip),%r8			#odd/even region for cos/sin
+	and	.L__reald_one_one(%rip),%r9			#odd/even region for cos/sin
+
+	shr	$1,%r10						#~AB+A~B, A is sign and B is upper bit of region
+	shr	$1,%r11						#~AB+A~B, A is sign and B is upper bit of region
+
+	mov	%r10,%rax
+	mov	%r11,%rcx
+
+	not 	%r12						#ADDED TO CHANGE THE LOGIC
+	not 	%r13						#ADDED TO CHANGE THE LOGIC
+	and	%r12,%r10
+	and	%r13,%r11
+
+	not	%rax
+	not	%rcx
+	not	%r12
+	not	%r13
+	and	%r12,%rax
+	and	%r13,%rcx
+
+	or	%rax,%r10
+	or	%rcx,%r11
+	and	.L__reald_one_one(%rip),%r10				#(~AB+A~B)&1
+	and	.L__reald_one_one(%rip),%r11				#(~AB+A~B)&1
+
+	mov	%r10,%r12
+	mov	%r11,%r13
+
+	and	%rdx,%r12				#mask out the lower sign bit leaving the upper sign bit
+	and	%rdx,%r13				#mask out the lower sign bit leaving the upper sign bit
+
+	shl	$63,%r10				#shift lower sign bit left by 63 bits
+	shl	$63,%r11				#shift lower sign bit left by 63 bits
+	shl	$31,%r12				#shift upper sign bit left by 31 bits
+	shl	$31,%r13				#shift upper sign bit left by 31 bits
+
+	mov 	 %r10,p_sign(%rsp)		#write out lower sign bit
+	mov 	 %r12,p_sign+8(%rsp)		#write out upper sign bit
+	mov 	 %r11,p_sign1(%rsp)		#write out lower sign bit
+	mov 	 %r13,p_sign1+8(%rsp)		#write out upper sign bit
+
+# GET_BITS_DP64(rhead-rtail, uy);			   		; originally only rhead
+# xmm4  = Sign, xmm0 =rhead, xmm8 =rtail
+# xmm5  = Sign, xmm1 =rhead, xmm9 =rtail
+	movapd	%xmm0,%xmm6						# rhead
+	movapd	%xmm1,%xmm7						# rhead
+
+	subpd	%xmm8,%xmm0						# r = rhead - rtail
+	subpd	%xmm9,%xmm1						# r = rhead - rtail
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm4  = Sign, xmm0 = r, xmm6 =rhead, xmm8 =rtail
+# xmm5  = Sign, xmm1 = r, xmm7 =rhead, xmm9 =rtail
+
+	subpd	%xmm0,%xmm6				#rr=rhead-r
+	subpd	%xmm1,%xmm7				#rr=rhead-r
+
+	mov	%r8,%rax
+	mov	%r9,%rcx
+
+	movapd	%xmm0,%xmm2				# move r for r2
+	movapd	%xmm1,%xmm3				# move r for r2
+
+	mulpd	%xmm0,%xmm2				# r2
+	mulpd	%xmm1,%xmm3				# r2
+
+	subpd	%xmm8,%xmm6				#rr=(rhead-r) -rtail
+	subpd	%xmm9,%xmm7				#rr=(rhead-r) -rtail
+
+
+	and	.L__reald_zero_one(%rip),%rax
+	and	.L__reald_zero_one(%rip),%rcx
+	shr	$31,%r8
+	shr	$31,%r9
+	or	%r8,%rax
+	or	%r9,%rcx
+	shl	$2,%rcx
+	or	%rcx,%rax
+
+#DEBUG
+#	jmp	.Lfinal_check
+#DEBUG
+
+	leaq	 .Levensin_oddcos_tbl(%rip),%rsi
+	jmp	 *(%rsi,%rax,8)				#Jmp table for cos/sin calculation based on even/odd region
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lfirst_or_next3_arg_gt_5e5:
+# %rcx,,%rax r8, r9
+
+	cmp	%r10,%rcx				#is upper arg >= 5e5
+	jae	.Lboth_arg_gt_5e5
+
+.Llower_arg_gt_5e5:
+# Upper Arg is < 5e5, Lower arg is >= 5e5
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+# Be sure not to use %xmm3,%xmm1 and xmm7
+# Use %xmm8,,%xmm5 xmm10, xmm12
+#	    %xmm11,,%xmm9 xmm13
+
+
+	movlpd	 %xmm0,r(%rsp)			#Save lower fp arg for remainder_piby2 call
+	movhlps	%xmm0,%xmm0			#Needed since we want to work on upper arg
+	movhlps	%xmm2,%xmm2
+	movhlps	%xmm6,%xmm6
+
+# Work on Upper arg
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm4,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm8		# xmm8 = piby2_1
+	cvttsd2si	%xmm2,%ecx				# ecx = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm10		# xmm10 = piby2_2
+	cvtsi2sd	%ecx,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm8					# npi2 * piby2_1
+	subsd	%xmm8,%xmm6					# xmm6 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm12		# xmm12 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm6,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm10					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm10,%xmm6					# xmm6 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm12     					# npi2 * piby2_2tail
+       subsd	%xmm6,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm10					# (rtail-(t-rhead))
+       addsd	%xmm12,%xmm10					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %ecx,region+4(%rsp)			# store upper region
+       movsd	%xmm6,%xmm0
+       subsd	%xmm10,%xmm0					# xmm0 = r=(rhead-rtail)
+       subsd	%xmm0,%xmm6					# rr=rhead-r
+       subsd	%xmm10,%xmm6					# xmm6 = rr=((rhead-r) -rtail)
+       movlpd	 %xmm0,r+8(%rsp)			# store upper r
+       movlpd	 %xmm6,rr+8(%rsp)			# store upper rr
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#Note that volatiles will be trashed by the call
+#We will construct r, rr, region and sign
+
+# Work on Lower arg
+	mov		$0x07ff0000000000000,%r11			# is lower arg nan/inf
+	mov		%r11,%r10
+	and		%rax,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_sin_lower_naninf
+
+
+	mov	  %r8,p_temp(%rsp)
+	mov	  %r9,p_temp2(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region(%rsp),%rdx			# lower arg is **NOT** nan/inf
+	lea	 rr(%rsp),%rsi
+	lea	 r(%rsp),%rdi
+	movlpd	 r(%rsp),%xmm0				#Restore lower fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+
+	mov	 p_temp(%rsp),%r8
+	mov	 p_temp2(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+	jmp 	0f
+
+.L__vrd4_sin_lower_naninf:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rax
+	mov	 %rax,r(%rsp)				# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr(%rsp)				# rr = 0
+	mov	 %r10d,region(%rsp)			# region =0
+
+.align 16
+0:
+	jmp .Lcheck_next2_args
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lboth_arg_gt_5e5:
+#Upper Arg is >= 5e5, Lower arg is >= 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+
+	movhpd		%xmm0,r+8(%rsp)					#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r11			#is lower arg nan/inf
+	mov		%r11,%r10
+	and		%rax,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_sin_lower_naninf_of_both_gt_5e5
+
+	mov	  %rcx,p_temp(%rsp)			#Save upper arg
+	mov	  %r8,p_temp2(%rsp)
+	mov	  %r9,p_temp4(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	 rr(%rsp),%rsi
+	lea	 r(%rsp),%rdi
+        call    __amd_remainder_piby2@PLT
+
+	mov	 p_temp2(%rsp),%r8
+	mov	 p_temp4(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+
+	mov	 p_temp(%rsp),%rcx			#Restore upper arg
+	jmp 	0f
+
+.L__vrd4_sin_lower_naninf_of_both_gt_5e5:				#lower arg is nan/inf
+#	mov	p_original(r%sp),%rax
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rax
+	mov	%rax,r(%rsp)				#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	%r10,rr(%rsp)				#rr = 0
+	mov	%r10d,region(%rsp)			#region = 0
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r11			#is upper arg nan/inf
+	mov		%r11,%r10
+	and		%rcx,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_sin_upper_naninf_of_both_gt_5e5
+
+
+	mov	  %r8,p_temp2(%rsp)
+	mov	  %r9,p_temp4(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region+4(%rsp),%rdx			#upper arg is **NOT** nan/inf
+	lea	 rr+8(%rsp),%rsi
+	lea	 r+8(%rsp),%rdi
+	movlpd	 r+8(%rsp),%xmm0			#Restore upper fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+
+	mov	 p_temp2(%rsp),%r8
+	mov	 p_temp4(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+
+	jmp 	0f
+
+.L__vrd4_sin_upper_naninf_of_both_gt_5e5:
+#	mov	p_original+8(%rsp),%rcx				;upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rcx
+	mov	%rcx,r+8(%rsp)				#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	%r10,rr+8(%rsp)			#rr = 0
+	mov	%r10d,region+4(%rsp)			#region = 0
+
+.align 16
+0:
+	jmp .Lcheck_next2_args
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lsecond_or_next2_arg_gt_5e5:
+
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+# Do not use %xmm3,,%xmm1 xmm7
+# Restore xmm4 and %xmm3,,%xmm1 xmm7
+# Can use %xmm10,,%xmm8 xmm12
+#   %xmm9,,%xmm5 xmm11, xmm13
+
+	movhpd	 %xmm0,r+8(%rsp)	#Save upper fp arg for remainder_piby2 call
+#	movlhps	%xmm0,%xmm0			;Not needed since we want to work on lower arg, but done just to be safe and avoide exceptions due to nan/inf and to mirror the lower_arg_gt_5e5 case
+#	movlhps	%xmm2,%xmm2
+#	movlhps	%xmm6,%xmm6
+
+# Work on Lower arg
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm4,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm8		# xmm3 = piby2_1
+	cvttsd2si	%xmm2,%eax				# ecx = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm10		# xmm1 = piby2_2
+	cvtsi2sd	%eax,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm8					# npi2 * piby2_1
+	subsd	%xmm8,%xmm6					# xmm6 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm12		# xmm7 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm6,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm10					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm10,%xmm6					# xmm6 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm12     					# npi2 * piby2_2tail
+       subsd	%xmm6,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm10					# (rtail-(t-rhead))
+       addsd	%xmm12,%xmm10					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %eax,region(%rsp)			# store upper region
+       movsd	%xmm6,%xmm0
+       subsd	%xmm10,%xmm0					# xmm0 = r=(rhead-rtail)
+       subsd	%xmm0,%xmm6					# rr=rhead-r
+       subsd	%xmm10,%xmm6					# xmm6 = rr=((rhead-r) -rtail)
+       movlpd	 %xmm0,r(%rsp)				# store upper r
+       movlpd	 %xmm6,rr(%rsp)				# store upper rr
+
+#Work on Upper arg
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+	mov		$0x07ff0000000000000,%r11			# is upper arg nan/inf
+	mov		%r11,%r10
+	and		%rcx,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_sin_upper_naninf
+
+
+	mov	 %r8,p_temp(%rsp)
+	mov	 %r9,p_temp2(%rsp)
+	movapd	 %xmm1,p_temp1(%rsp)
+	movapd	 %xmm3,p_temp3(%rsp)
+	movapd	 %xmm7,p_temp5(%rsp)
+
+	lea	 region+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 rr+8(%rsp),%rsi
+	lea	 r+8(%rsp),%rdi
+	movlpd	 r+8(%rsp),%xmm0	#Restore upper fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+
+	mov	p_temp(%rsp),%r8
+	mov	p_temp2(%rsp),%r9
+	movapd	p_temp1(%rsp),%xmm1
+	movapd	p_temp3(%rsp),%xmm3
+	movapd	p_temp5(%rsp),%xmm7
+	jmp 	0f
+
+.L__vrd4_sin_upper_naninf:
+#	mov	p_original+8(%rsp),%rcx		; upper arg is nan/inf
+#	mov	r+8(%rsp),%rcx			; upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rcx
+	mov	 %rcx,r+8(%rsp)				# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr+8(%rsp)			# rr = 0
+	mov	 %r10d,region+4(%rsp)			# region =0
+
+.align 16
+0:
+
+	jmp 	.Lcheck_next2_args
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcheck_next2_args:
+
+	mov	$0x411E848000000000,%r10			#5e5	+
+
+	cmp	%r10,%r8
+	jae	.Lfirst_second_done_third_or_fourth_arg_gt_5e5
+
+	cmp	%r10,%r9
+	jae	.Lfirst_second_done_fourth_arg_gt_5e5
+
+
+
+# Work on next two args, both < 5e5
+# %xmm3,,%xmm1 xmm5 = x, xmm4 = 0.5
+
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4			#Restore 0.5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm3						# * twobypi
+	addpd	%xmm4,%xmm3						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm1		# piby2_1
+	cvttpd2dq	%xmm3,%xmm5					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm9		# piby2_2
+	cvtdq2pd	%xmm5,%xmm3					# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+       movq	 %xmm5,region1(%rsp)						# Region
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm3,%xmm1						# npi2 * piby2_1;
+
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm3,%xmm9						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm1,%xmm7						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm7,%xmm1						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm9,%xmm1						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm3		# npi2 * piby2_2tail
+
+       subpd	%xmm1,%xmm7						# t-rhead
+       subpd	%xmm7,%xmm9						# - ((t - rhead) - rtail)
+       addpd	%xmm3,%xmm9						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+       movapd	%xmm1,%xmm7						# rhead
+       subpd	%xmm9,%xmm1						# r = rhead - rtail
+       movapd	 %xmm1,r1(%rsp)
+
+       subpd	%xmm1,%xmm7						# rr=rhead-r
+       subpd	%xmm9,%xmm7						# rr=(rhead-r) -rtail
+       movapd	 %xmm7,rr1(%rsp)
+
+	jmp	.L__vrd4_sin_reconstruct
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lthird_or_fourth_arg_gt_5e5:
+#first two args are < 5e5, third arg >= 5e5, fourth arg >= 5e5 or < 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+# Do not use %xmm3,,%xmm1 xmm7
+# Can use 	%xmm11,,%xmm9 xmm13
+# 	%xmm8,,%xmm5 xmm10, xmm12
+# Restore xmm4
+
+# Work on first two args, both < 5e5
+
+
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm2						# * twobypi
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm0		# piby2_1
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movq	 %xmm4,region(%rsp)				# Region
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm0						# npi2 * piby2_1;
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm0,%xmm6						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm0						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm0						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+
+       subpd	%xmm0,%xmm6						# t-rhead
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+       movapd	%xmm0,%xmm6						# rhead
+       subpd	%xmm8,%xmm0						# r = rhead - rtail
+       movapd	 %xmm0,r(%rsp)
+
+       subpd	%xmm0,%xmm6						# rr=rhead-r
+       subpd	%xmm8,%xmm6						# rr=(rhead-r) -rtail
+       movapd	 %xmm6,rr(%rsp)
+
+
+# Work on next two args, third arg >= 5e5, fourth arg >= 5e5 or < 5e5
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lfirst_second_done_third_or_fourth_arg_gt_5e5:
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+
+	mov	$0x411E848000000000,%r10			#5e5	+
+	cmp	%r10,%r9
+	jae	.Lboth_arg_gt_5e5_higher
+
+
+# Upper Arg is <5e5, Lower arg is >= 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+	movlpd	 %xmm1,r1(%rsp)		#Save lower fp arg for remainder_piby2 call
+	movhlps	%xmm1,%xmm1			#Needed since we want to work on upper arg
+	movhlps	%xmm3,%xmm3
+	movhlps	%xmm7,%xmm7
+
+
+# Work on Upper arg
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4		# Restore 0.5
+
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm3		# x*twobypi
+	addsd	%xmm4,%xmm3					# xmm3 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm2		# xmm2 = piby2_1
+	cvttsd2si	%xmm3,%r9d				# r9d = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm0		# xmm0 = piby2_2
+	cvtsi2sd	%r9d,%xmm3				# xmm3 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm3,%xmm2					# npi2 * piby2_1
+	subsd	%xmm2,%xmm7					# xmm7 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm7,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm3,%xmm0					# xmm0 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm0,%xmm7					# xmm7 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm3,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm7,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm0					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm0					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %r9d,region1+4(%rsp)			# store upper region
+       movsd	%xmm7,%xmm1
+       subsd	%xmm0,%xmm1					# xmm1 = r=(rhead-rtail)
+       subsd	%xmm1,%xmm7					# rr=rhead-r
+       subsd	%xmm0,%xmm7					# xmm7 = rr=((rhead-r) -rtail)
+       movlpd	 %xmm1,r1+8(%rsp)			# store upper r
+       movlpd	 %xmm7,rr1+8(%rsp)			# store upper rr
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+
+# Work on Lower arg
+	mov		$0x07ff0000000000000,%r11			# is lower arg nan/inf
+	mov		%r11,%r10
+	and		%r8,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_sin_lower_naninf_higher
+
+	lea	 region1(%rsp),%rdx			# lower arg is **NOT** nan/inf
+	lea	 rr1(%rsp),%rsi
+	lea	 r1(%rsp),%rdi
+	movlpd	 r1(%rsp),%xmm0				#Restore lower fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+	jmp 	0f
+
+.L__vrd4_sin_lower_naninf_higher:
+#	mov	p_original1(%rsp),%r8			; upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r8
+	mov	 %r8,r1(%rsp)				# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr1(%rsp)				# rr = 0
+	mov	 %r10d,region1(%rsp)			# region =0
+
+.align 16
+0:
+	jmp 	.L__vrd4_sin_reconstruct
+
+.align 16
+.Lboth_arg_gt_5e5_higher:
+# Upper Arg is >= 5e5, Lower arg is >= 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+
+	movhpd 		%xmm1,r1+8(%rsp)		#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r11			#is lower arg nan/inf
+	mov		%r11,%r10
+	and		%r8,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_sin_lower_naninf_of_both_gt_5e5_higher
+
+	mov	 %r9,p_temp1(%rsp)			#Save upper arg
+	lea	 region1(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	 rr1(%rsp),%rsi
+	lea	 r1(%rsp),%rdi
+	movsd	 %xmm1,%xmm0
+        call    __amd_remainder_piby2@PLT
+	mov	 p_temp1(%rsp),%r9			#Restore upper arg
+	jmp 	0f
+
+.L__vrd4_sin_lower_naninf_of_both_gt_5e5_higher:				#lower arg is nan/inf
+#	mov	p_original1(%rsp),%r8
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r8
+	mov	%r8,r1(%rsp)				#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	%r10,rr1(%rsp)				#rr = 0
+	mov	%r10d,region1(%rsp)			#region = 0
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r11			#is upper arg nan/inf
+	mov		%r11,%r10
+	and		%r9,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_sin_upper_naninf_of_both_gt_5e5_higher
+
+	lea	 region1+4(%rsp),%rdx			#upper arg is **NOT** nan/inf
+	lea	 rr1+8(%rsp),%rsi
+	lea	 r1+8(%rsp),%rdi
+	movlpd	 r1+8(%rsp),%xmm0			#Restore upper fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+	jmp 	0f
+
+.L__vrd4_sin_upper_naninf_of_both_gt_5e5_higher:
+#	mov	p_original1+8(%rsp),%r9			;upper arg is nan/inf
+#	movd	%xmm6,%r9				;upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r9
+	mov	%r9,r1+8(%rsp)				#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	%r10,rr1+8(%rsp)			#rr = 0
+	mov	%r10d,region1+4(%rsp)			#region = 0
+
+.align 16
+0:
+	jmp .L__vrd4_sin_reconstruct
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lfourth_arg_gt_5e5:
+#first two args are < 5e5, third arg < 5e5, fourth arg >= 5e5
+#%rcx,,%rax r8, r9
+#%xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+
+# Work on first two args, both < 5e5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm2						# * twobypi
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm0		# piby2_1
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movq	 %xmm4,region(%rsp)						# Region
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm0						# npi2 * piby2_1;
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm0,%xmm6						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm0						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm0						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+
+       subpd	%xmm0,%xmm6						# t-rhead
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+       movapd	%xmm0,%xmm6						# rhead
+       subpd	%xmm8,%xmm0						# r = rhead - rtail
+       movapd	 %xmm0,r(%rsp)
+
+       subpd	%xmm0,%xmm6						# rr=rhead-r
+       subpd	%xmm8,%xmm6						# rr=(rhead-r) -rtail
+       movapd	 %xmm6,rr(%rsp)
+
+
+# Work on next two args, third arg < 5e5, fourth arg >= 5e5
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lfirst_second_done_fourth_arg_gt_5e5:
+
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+	movhpd	 %xmm1,r1+8(%rsp)	#Save upper fp arg for remainder_piby2 call
+#	movlhps	%xmm1,%xmm1			;Not needed since we want to work on lower arg, but done just to be safe and avoide exceptions due to nan/inf and to mirror the lower_arg_gt_5e5 case
+#	movlhps	%xmm3,%xmm3
+#	movlhps	%xmm7,%xmm7
+
+
+# Work on Lower arg
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4		# Restore 0.5
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm3		# x*twobypi
+	addsd	%xmm4,%xmm3					# xmm3 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm2		# xmm2 = piby2_1
+	cvttsd2si	%xmm3,%r8d				# r8d = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm0		# xmm0 = piby2_2
+	cvtsi2sd	%r8d,%xmm3				# xmm3 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm3,%xmm2					# npi2 * piby2_1
+	subsd	%xmm2,%xmm7					# xmm7 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm7,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm3,%xmm0					# xmm0 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm0,%xmm7					# xmm7 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm3,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm7,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm0					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm0					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %r8d,region1(%rsp)			# store lower region
+       movsd	%xmm7,%xmm1
+       subsd	%xmm0,%xmm1					# xmm0 = r=(rhead-rtail)
+       subsd	%xmm1,%xmm7					# rr=rhead-r
+       subsd	%xmm0,%xmm7					# xmm6 = rr=((rhead-r) -rtail)
+
+       movlpd	 %xmm1,r1(%rsp)				# store upper r
+       movlpd	 %xmm7,rr1(%rsp)				# store upper rr
+
+#Work on Upper arg
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+	mov		$0x07ff0000000000000,%r11			# is upper arg nan/inf
+	mov		%r11,%r10
+	and		%r9,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_sin_upper_naninf_higher
+
+	lea	 region1+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 rr1+8(%rsp),%rsi
+	lea	 r1+8(%rsp),%rdi
+	movlpd	 r1+8(%rsp),%xmm0	#Restore upper fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+	jmp 	0f
+
+.L__vrd4_sin_upper_naninf_higher:
+#	mov	p_original1+8(%rsp),%r9		; upper arg is nan/inf
+#	mov	r1+8(%rsp),%r9				; upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r9
+	mov	%r9,r1+8(%rsp)				# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	%r10,rr1+8(%rsp)			# rr = 0
+	mov	%r10d,region1+4(%rsp)			# region =0
+
+.align 16
+0:
+	jmp	.L__vrd4_sin_reconstruct
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrd4_sin_reconstruct:
+#Results
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	movapd	r(%rsp),%xmm0
+	movapd	r1(%rsp),%xmm1
+
+	movapd	rr(%rsp),%xmm6
+	movapd	rr1(%rsp),%xmm7
+
+	mov	region(%rsp),%r8
+	mov	region1(%rsp),%r9
+	mov 	.L__reald_one_zero(%rip),%rdx		#compare value for cossin path
+
+	mov 	%r8,%r10
+	mov 	%r9,%r11
+
+	and	.L__reald_one_one(%rip),%r8		#odd/even region for cos/sin
+	and	.L__reald_one_one(%rip),%r9		#odd/even region for cos/sin
+
+	shr	$1,%r10						#~AB+A~B, A is sign and B is upper bit of region
+	shr	$1,%r11						#~AB+A~B, A is sign and B is upper bit of region
+
+	mov	%r10,%rax
+	mov	%r11,%rcx
+
+	not 	%r12						#ADDED TO CHANGE THE LOGIC
+	not 	%r13						#ADDED TO CHANGE THE LOGIC
+	and	%r12,%r10
+	and	%r13,%r11
+
+	not	%rax
+	not	%rcx
+	not	%r12
+	not	%r13
+	and	%r12,%rax
+	and	%r13,%rcx
+
+	or	%rax,%r10
+	or	%rcx,%r11
+	and	.L__reald_one_one(%rip),%r10				#(~AB+A~B)&1
+	and	.L__reald_one_one(%rip),%r11				#(~AB+A~B)&1
+
+	mov	%r10,%r12
+	mov	%r11,%r13
+
+	and	%rdx,%r12				#mask out the lower sign bit leaving the upper sign bit
+	and	%rdx,%r13				#mask out the lower sign bit leaving the upper sign bit
+
+	shl	$63,%r10				#shift lower sign bit left by 63 bits
+	shl	$63,%r11				#shift lower sign bit left by 63 bits
+	shl	$31,%r12				#shift upper sign bit left by 31 bits
+	shl	$31,%r13				#shift upper sign bit left by 31 bits
+
+	mov 	 %r10,p_sign(%rsp)		#write out lower sign bit
+	mov 	 %r12,p_sign+8(%rsp)		#write out upper sign bit
+	mov 	 %r11,p_sign1(%rsp)		#write out lower sign bit
+	mov 	 %r13,p_sign1+8(%rsp)		#write out upper sign bit
+
+	mov	%r8,%rax
+	mov	%r9,%rcx
+
+	movapd	%xmm0,%xmm2
+	movapd	%xmm1,%xmm3
+
+	mulpd	%xmm0,%xmm2				# r2
+	mulpd	%xmm1,%xmm3				# r2
+
+	and	.L__reald_zero_one(%rip),%rax
+	and	.L__reald_zero_one(%rip),%rcx
+	shr	$31,%r8
+	shr	$31,%r9
+	or	%r8,%rax
+	or	%r9,%rcx
+	shl	$2,%rcx
+	or	%rcx,%rax
+
+	leaq	 .Levensin_oddcos_tbl(%rip),%rsi
+	jmp	 *(%rsi,%rax,8)				#Jmp table for cos/sin calculation based on even/odd region
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrd4_sin_cleanup:
+
+	movapd	p_sign(%rsp),%xmm0
+	movapd	p_sign1(%rsp),%xmm1
+	xorpd	%xmm4,%xmm0			# (+) Sign
+	xorpd	%xmm5,%xmm1			# (+) Sign
+
+.Lfinal_check:
+	mov	save_r12(%rsp),%r12	# restore r12
+	mov	save_r13(%rsp),%r13	# restore r13
+
+	add	$0x1E8,%rsp
+	ret
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;JUMP TABLE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcoscos_coscos_piby4:
+
+
+	movapd	%xmm2,%xmm10					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lcosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lcosarray+0x50(%rip),%xmm5			# c6
+
+	movapd	.Lcosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lcosarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# r
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm10		# -t=r-1.0	;trash r
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11		# -t=r-1.0	;trash r
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lcosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lcosarray+0x40(%rip),%xmm5			# c5+x2c6
+
+	addpd	.Lcosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lcosarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm10		# 1 + (-t)	;trash t
+	addpd   .L__real_3ff0000000000000(%rip),%xmm11		# 1 + (-t)	;trash t
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lcosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+
+	addpd	.Lcosarray(%rip),%xmm8				# c1 + x2(c2+x2C3)
+	addpd	.Lcosarray(%rip),%xmm9				# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm2,%xmm2					# x4 recalculate
+	mulpd	%xmm3,%xmm3					# x4 recalculate
+
+	movapd   p_temp2(%rsp),%xmm12			# r
+	movapd   p_temp3(%rsp),%xmm13			# r
+
+	mulpd	%xmm0,%xmm6					# x * xx
+	mulpd	%xmm1,%xmm7					# x * xx
+
+	subpd   %xmm12,%xmm10					# (1 + (-t)) - r
+	subpd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x4 * zc
+
+	subpd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx
+	subpd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	addpd   %xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addpd   %xmm11,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm12		# t relaculate, -t = r-1
+	subpd	.L__real_3ff0000000000000(%rip),%xmm13		# t relaculate, -t = r-1
+
+	subpd   %xmm12,%xmm4					# + t
+	subpd   %xmm13,%xmm5					# + t
+
+	jmp	.L__vrd4_sin_cleanup
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcossin_cossin_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	movapd	 %xmm6,p_temp(%rsp)		# Store rr
+	movapd	 %xmm7,p_temp1(%rsp)		# Store rr
+
+	movdqa	.Lsincosarray+0x50(%rip),%xmm4		# s6
+	movdqa	.Lsincosarray+0x50(%rip),%xmm5		# s6
+	movapd	.Lsincosarray+0x20(%rip),%xmm8		# s3
+	movapd	.Lsincosarray+0x20(%rip),%xmm9		# s3
+
+	movapd	%xmm2,%xmm10				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+
+	mulpd	%xmm2,%xmm4				# x2s6
+	mulpd	%xmm3,%xmm5				# x2s6
+	mulpd	%xmm2,%xmm8				# x2s3
+	mulpd	%xmm3,%xmm9				# x2s3
+
+	mulpd	%xmm2,%xmm10				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lsincosarray+0x40(%rip),%xmm4		# s5+x2s6
+	addpd	.Lsincosarray+0x40(%rip),%xmm5		# s5+x2s6
+	addpd	.Lsincosarray+0x10(%rip),%xmm8		# s2+x2s3
+	addpd	.Lsincosarray+0x10(%rip),%xmm9		# s2+x2s3
+
+	movapd	%xmm2,%xmm12				# move x2 for x6
+	movapd	%xmm3,%xmm13				# move x2 for x6
+
+	mulpd	%xmm2,%xmm4				# x2(s5+x2s6)
+	mulpd	%xmm3,%xmm5				# x2(s5+x2s6)
+	mulpd	%xmm2,%xmm8				# x2(s2+x2s3)
+	mulpd	%xmm3,%xmm9				# x2(s2+x2s3)
+
+	mulpd	%xmm10,%xmm12				# x6
+	mulpd	%xmm11,%xmm13				# x6
+
+	addpd	.Lsincosarray+0x30(%rip),%xmm4		# s4+x2(s5+x2s6)
+	addpd	.Lsincosarray+0x30(%rip),%xmm5		# s4+x2(s5+x2s6)
+	addpd	.Lsincosarray(%rip),%xmm8		# s1+x2(s2+x2s3)
+	addpd	.Lsincosarray(%rip),%xmm9		# s1+x2(s2+x2s3)
+
+	movhlps	%xmm10,%xmm10				# move high x4 for cos term
+	movhlps	%xmm11,%xmm11				# move high x4 for cos term
+	mulpd	%xmm12,%xmm4				# x6(s4+x2(s5+x2s6))
+	mulpd	%xmm13,%xmm5				# x6(s4+x2(s5+x2s6))
+
+	movsd	%xmm2,%xmm6				# move low x2 for x3 for sin term
+	movsd	%xmm3,%xmm7				# move low x2 for x3 for sin term
+	mulsd	%xmm0,%xmm6				# get low x3 for sin term
+	mulsd	%xmm1,%xmm7				# get low x3 for sin term
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for sin and cos terms
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for sin and cos terms
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm2,%xmm12				# move high r for cos
+	movhlps	%xmm3,%xmm13				# move high r for cos
+	movhlps	%xmm4,%xmm8				# xmm4 = sin , xmm8 = cos
+	movhlps	%xmm5,%xmm9				# xmm4 = sin , xmm8 = cos
+
+	mulsd	%xmm6,%xmm4				# sin *x3
+	mulsd	%xmm7,%xmm5				# sin *x3
+	mulsd	%xmm10,%xmm8				# cos *x4
+	mulsd	%xmm11,%xmm9				# cos *x4
+
+	mulsd	p_temp(%rsp),%xmm2		# 0.5 * x2 * xx for sin term
+	mulsd	p_temp1(%rsp),%xmm3		# 0.5 * x2 * xx for sin term
+	movsd	%xmm12,%xmm6				# Keep high r for cos term
+	movsd	%xmm13,%xmm7				# Keep high r for cos term
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12 	#-t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13 	#-t=r-1.0
+
+	subsd	%xmm2,%xmm4				# sin - 0.5 * x2 *xx
+	subsd	%xmm3,%xmm5				# sin - 0.5 * x2 *xx
+
+	movhlps	%xmm0,%xmm10				# move high x for x*xx for cos term
+	movhlps	%xmm1,%xmm11				# move high x for x*xx for cos term
+
+	mulsd	p_temp+8(%rsp),%xmm10		# x * xx
+	mulsd	p_temp1+8(%rsp),%xmm11		# x * xx
+
+	movsd	%xmm12,%xmm2				# move -t for cos term
+	movsd	%xmm13,%xmm3				# move -t for cos term
+
+	addsd	.L__real_3ff0000000000000(%rip),%xmm12 	#1+(-t)
+	addsd	.L__real_3ff0000000000000(%rip),%xmm13 	#1+(-t)
+	addsd	p_temp(%rsp),%xmm4			# sin+xx
+	addsd	p_temp1(%rsp),%xmm5			# sin+xx
+	subsd	%xmm6,%xmm12				# (1-t) - r
+	subsd	%xmm7,%xmm13				# (1-t) - r
+	subsd	%xmm10,%xmm12				# ((1 + (-t)) - r) - x*xx
+	subsd	%xmm11,%xmm13				# ((1 + (-t)) - r) - x*xx
+	addsd	%xmm0,%xmm4				# sin + x
+	addsd	%xmm1,%xmm5				# sin + x
+	addsd   %xmm12,%xmm8				# cos+((1-t)-r - x*xx)
+	addsd   %xmm13,%xmm9				# cos+((1-t)-r - x*xx)
+	subsd   %xmm2,%xmm8				# cos+t
+	subsd   %xmm3,%xmm9				# cos+t
+
+	movlhps	%xmm8,%xmm4
+	movlhps	%xmm9,%xmm5
+	jmp 	.L__vrd4_sin_cleanup
+
+.align 16
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lsincos_cossin_piby4:					# changed from sincos_sincos
+							# xmm1 is cossin and xmm0 is sincos
+
+	movapd	 %xmm6,p_temp(%rsp)		# Store rr
+	movapd	 %xmm7,p_temp1(%rsp)		# Store rr
+	movapd	 %xmm1,p_temp3(%rsp)		# Store r for the sincos term
+
+	movapd	.Lsincosarray+0x50(%rip),%xmm4		# s6
+	movapd	.Lcossinarray+0x50(%rip),%xmm5		# s6
+	movdqa	.Lsincosarray+0x20(%rip),%xmm8		# s3
+	movdqa	.Lcossinarray+0x20(%rip),%xmm9		# s3
+
+	movapd	%xmm2,%xmm10				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+
+	mulpd	%xmm2,%xmm4				# x2s6
+	mulpd	%xmm3,%xmm5				# x2s6
+	mulpd	%xmm2,%xmm8				# x2s3
+	mulpd	%xmm3,%xmm9				# x2s3
+
+	mulpd	%xmm2,%xmm10				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lsincosarray+0x40(%rip),%xmm4		# s5+x2s6
+	addpd	.Lcossinarray+0x40(%rip),%xmm5		# s5+x2s6
+	addpd	.Lsincosarray+0x10(%rip),%xmm8		# s2+x2s3
+	addpd	.Lcossinarray+0x10(%rip),%xmm9		# s2+x2s3
+
+	movapd	%xmm2,%xmm12				# move x2 for x6
+	movapd	%xmm3,%xmm13				# move x2 for x6
+
+	mulpd	%xmm2,%xmm4				# x2(s5+x2s6)
+	mulpd	%xmm3,%xmm5				# x2(s5+x2s6)
+	mulpd	%xmm2,%xmm8				# x2(s2+x2s3)
+	mulpd	%xmm3,%xmm9				# x2(s2+x2s3)
+
+	mulpd	%xmm10,%xmm12				# x6
+	mulpd	%xmm11,%xmm13				# x6
+
+	addpd	.Lsincosarray+0x30(%rip),%xmm4		# s4+x2(s5+x2s6)
+	addpd	.Lcossinarray+0x30(%rip),%xmm5		# s4+x2(s5+x2s6)
+	addpd	.Lsincosarray(%rip),%xmm8		# s1+x2(s2+x2s3)
+	addpd	.Lcossinarray(%rip),%xmm9		# s1+x2(s2+x2s3)
+
+	movhlps	%xmm10,%xmm10				# move high x4 for cos term
+
+	mulpd	%xmm12,%xmm4				# x6(s4+x2(s5+x2s6))
+	mulpd	%xmm13,%xmm5				# x6(s4+x2(s5+x2s6))
+
+	movsd	%xmm2,%xmm6				# move low x2 for x3 for sin term  (cossin)
+	movhlps	%xmm3,%xmm7				# move high x2 for x3 for sin term (sincos)
+
+	mulsd	%xmm0,%xmm6				# get low x3 for sin term
+	mulsd	p_temp3+8(%rsp),%xmm7			# get high x3 for sin term
+
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for sin and cos terms
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for sin and cos terms
+
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm2,%xmm12				# move high r for cos (cossin)
+	movhlps	%xmm3,%xmm13				# move high 0.5*x2 for sin term (sincos)
+
+	movhlps	%xmm4,%xmm8				# xmm8 = cos , xmm4 = sin	(cossin)
+	movhlps	%xmm5,%xmm9				# xmm9 = sin , xmm5 = cos	(sincos)
+
+	mulsd	%xmm6,%xmm4				# sin *x3
+	mulsd	%xmm11,%xmm5				# cos *x4
+	mulsd	%xmm10,%xmm8				# cos *x4
+	mulsd	%xmm7,%xmm9				# sin *x3
+
+	mulsd	p_temp(%rsp),%xmm2		# low  0.5 * x2 * xx for sin term (cossin)
+	mulsd	p_temp1+8(%rsp),%xmm13		# high 0.5 * x2 * xx for sin term (sincos)
+
+	movsd	%xmm12,%xmm6				# Keep high r for cos term
+	movsd	%xmm3,%xmm7				# Keep low r for cos term
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12 	# -t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm3 	# -t=r-1.0
+
+	subsd	%xmm2,%xmm4				# sin - 0.5 * x2 *xx	(cossin)
+	subsd	%xmm13,%xmm9				# sin - 0.5 * x2 *xx	(sincos)
+
+	movhlps	%xmm0,%xmm10				# move high x for x*xx for cos term (cossin)
+	movhlps	%xmm1,%xmm11				# move high x for x for sin term    (sincos)
+
+	mulsd	p_temp+8(%rsp),%xmm10		# x * xx
+	mulsd	p_temp1(%rsp),%xmm1		# x * xx
+
+	movsd	%xmm12,%xmm2				# move -t for cos term
+	movsd	%xmm3,%xmm13				# move -t for cos term
+
+	addsd	.L__real_3ff0000000000000(%rip),%xmm12	# 1+(-t)
+	addsd	.L__real_3ff0000000000000(%rip),%xmm3 	# 1+(-t)
+
+	addsd	p_temp(%rsp),%xmm4		# sin+xx	+
+	addsd	p_temp1+8(%rsp),%xmm9		# sin+xx	+
+
+	subsd	%xmm6,%xmm12				# (1-t) - r
+	subsd	%xmm7,%xmm3				# (1-t) - r
+
+	subsd	%xmm10,%xmm12				# ((1 + (-t)) - r) - x*xx
+	subsd	%xmm1,%xmm3				# ((1 + (-t)) - r) - x*xx
+
+	addsd	%xmm0,%xmm4				# sin + x	+
+	addsd	%xmm11,%xmm9				# sin + x	+
+
+	addsd   %xmm12,%xmm8				# cos+((1-t)-r - x*xx)
+	addsd   %xmm3,%xmm5				# cos+((1-t)-r - x*xx)
+
+	subsd   %xmm2,%xmm8				# cos+t
+	subsd   %xmm13,%xmm5				# cos+t
+
+	movlhps	%xmm8,%xmm4				# cossin
+	movlhps	%xmm9,%xmm5				# sincos
+
+	jmp	.L__vrd4_sin_cleanup
+
+.align 16
+.Lsincos_sincos_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	movapd	 %xmm6,p_temp(%rsp)		# Store rr
+	movapd	 %xmm7,p_temp1(%rsp)		# Store rr
+	movapd	 %xmm0,p_temp2(%rsp)		# Store r
+	movapd	 %xmm1,p_temp3(%rsp)		# Store r
+
+
+	movapd	.Lcossinarray+0x50(%rip),%xmm4		# s6
+	movapd	.Lcossinarray+0x50(%rip),%xmm5		# s6
+	movdqa	.Lcossinarray+0x20(%rip),%xmm8		# s3
+	movdqa	.Lcossinarray+0x20(%rip),%xmm9		# s3
+
+	movapd	%xmm2,%xmm10				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+
+	mulpd	%xmm2,%xmm4				# x2s6
+	mulpd	%xmm3,%xmm5				# x2s6
+	mulpd	%xmm2,%xmm8				# x2s3
+	mulpd	%xmm3,%xmm9				# x2s3
+
+	mulpd	%xmm2,%xmm10				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lcossinarray+0x40(%rip),%xmm4		# s5+x2s6
+	addpd	.Lcossinarray+0x40(%rip),%xmm5		# s5+x2s6
+	addpd	.Lcossinarray+0x10(%rip),%xmm8		# s2+x2s3
+	addpd	.Lcossinarray+0x10(%rip),%xmm9		# s2+x2s3
+
+	movapd	%xmm2,%xmm12				# move x2 for x6
+	movapd	%xmm3,%xmm13				# move x2 for x6
+
+	mulpd	%xmm2,%xmm4				# x2(s5+x2s6)
+	mulpd	%xmm3,%xmm5				# x2(s5+x2s6)
+	mulpd	%xmm2,%xmm8				# x2(s2+x2s3)
+	mulpd	%xmm3,%xmm9				# x2(s2+x2s3)
+
+	mulpd	%xmm10,%xmm12				# x6
+	mulpd	%xmm11,%xmm13				# x6
+
+	addpd	.Lcossinarray+0x30(%rip),%xmm4		# s4+x2(s5+x2s6)
+	addpd	.Lcossinarray+0x30(%rip),%xmm5		# s4+x2(s5+x2s6)
+	addpd	.Lcossinarray(%rip),%xmm8		# s1+x2(s2+x2s3)
+	addpd	.Lcossinarray(%rip),%xmm9		# s1+x2(s2+x2s3)
+
+	mulpd	%xmm12,%xmm4				# x6(s4+x2(s5+x2s6))
+	mulpd	%xmm13,%xmm5				# x6(s4+x2(s5+x2s6))
+
+	movhlps	%xmm2,%xmm6				# move low x2 for x3 for sin term
+	movhlps	%xmm3,%xmm7				# move low x2 for x3 for sin term
+	mulsd	p_temp2+8(%rsp),%xmm6		# get low x3 for sin term
+	mulsd	p_temp3+8(%rsp),%xmm7		# get low x3 for sin term
+
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for sin and cos terms
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for sin and cos terms
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm2,%xmm12				# move high 0.5*x2 for sin term
+	movhlps	%xmm3,%xmm13				# move high 0.5*x2 for sin term
+							# Reverse 12 and 2
+
+	movhlps	%xmm4,%xmm8				# xmm8 = sin , xmm4 = cos
+	movhlps	%xmm5,%xmm9				# xmm9 = sin , xmm5 = cos
+
+	mulsd	%xmm6,%xmm8				# sin *x3
+	mulsd	%xmm7,%xmm9				# sin *x3
+	mulsd	%xmm10,%xmm4				# cos *x4
+	mulsd	%xmm11,%xmm5				# cos *x4
+
+	mulsd	p_temp+8(%rsp),%xmm12		# 0.5 * x2 * xx for sin term
+	mulsd	p_temp1+8(%rsp),%xmm13		# 0.5 * x2 * xx for sin term
+	movsd	%xmm2,%xmm6				# Keep high r for cos term
+	movsd	%xmm3,%xmm7				# Keep high r for cos term
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm2 	#-t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm3 	#-t=r-1.0
+
+	subsd	%xmm12,%xmm8				# sin - 0.5 * x2 *xx
+	subsd	%xmm13,%xmm9				# sin - 0.5 * x2 *xx
+
+	movhlps	%xmm0,%xmm10				# move high x for x for sin term
+	movhlps	%xmm1,%xmm11				# move high x for x for sin term
+							# Reverse 10 and 0
+
+	mulsd	p_temp(%rsp),%xmm0		# x * xx
+	mulsd	p_temp1(%rsp),%xmm1		# x * xx
+
+	movsd	%xmm2,%xmm12				# move -t for cos term
+	movsd	%xmm3,%xmm13				# move -t for cos term
+
+	addsd	.L__real_3ff0000000000000(%rip),%xmm2 	# 1+(-t)
+	addsd	.L__real_3ff0000000000000(%rip),%xmm3 	# 1+(-t)
+	addsd	p_temp+8(%rsp),%xmm8			# sin+xx
+	addsd	p_temp1+8(%rsp),%xmm9			# sin+xx
+
+	subsd	%xmm6,%xmm2				# (1-t) - r
+	subsd	%xmm7,%xmm3				# (1-t) - r
+
+	subsd	%xmm0,%xmm2				# ((1 + (-t)) - r) - x*xx
+	subsd	%xmm1,%xmm3				# ((1 + (-t)) - r) - x*xx
+
+	addsd	%xmm10,%xmm8				# sin + x
+	addsd	%xmm11,%xmm9				# sin + x
+
+	addsd   %xmm2,%xmm4				# cos+((1-t)-r - x*xx)
+	addsd   %xmm3,%xmm5				# cos+((1-t)-r - x*xx)
+
+	subsd   %xmm12,%xmm4				# cos+t
+	subsd   %xmm13,%xmm5				# cos+t
+
+	movlhps	%xmm8,%xmm4
+	movlhps	%xmm9,%xmm5
+	jmp 	.L__vrd4_sin_cleanup
+
+.align 16
+.Lcossin_sincos_piby4:					# changed from sincos_sincos
+							# xmm1 is cossin and xmm0 is sincos
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	movapd	 %xmm6,p_temp(%rsp)		# Store rr
+	movapd	 %xmm7,p_temp1(%rsp)		# Store rr
+	movapd	 %xmm0,p_temp2(%rsp)		# Store r
+
+
+	movapd	.Lcossinarray+0x50(%rip),%xmm4		# s6
+	movapd	.Lsincosarray+0x50(%rip),%xmm5		# s6
+	movdqa	.Lcossinarray+0x20(%rip),%xmm8		# s3
+	movdqa	.Lsincosarray+0x20(%rip),%xmm9		# s3
+
+	movapd	%xmm2,%xmm10				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+
+	mulpd	%xmm2,%xmm4				# x2s6
+	mulpd	%xmm3,%xmm5				# x2s6
+	mulpd	%xmm2,%xmm8				# x2s3
+	mulpd	%xmm3,%xmm9				# x2s3
+
+	mulpd	%xmm2,%xmm10				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lcossinarray+0x40(%rip),%xmm4		# s5+x2s6
+	addpd	.Lsincosarray+0x40(%rip),%xmm5		# s5+x2s6
+	addpd	.Lcossinarray+0x10(%rip),%xmm8		# s2+x2s3
+	addpd	.Lsincosarray+0x10(%rip),%xmm9		# s2+x2s3
+
+	movapd	%xmm2,%xmm12				# move x2 for x6
+	movapd	%xmm3,%xmm13				# move x2 for x6
+
+	mulpd	%xmm2,%xmm4				# x2(s5+x2s6)
+	mulpd	%xmm3,%xmm5				# x2(s5+x2s6)
+	mulpd	%xmm2,%xmm8				# x2(s2+x2s3)
+	mulpd	%xmm3,%xmm9				# x2(s2+x2s3)
+
+	mulpd	%xmm10,%xmm12				# x6
+	mulpd	%xmm11,%xmm13				# x6
+
+	addpd	.Lcossinarray+0x30(%rip),%xmm4		# s4+x2(s5+x2s6)
+	addpd	.Lsincosarray+0x30(%rip),%xmm5		# s4+x2(s5+x2s6)
+	addpd	.Lcossinarray(%rip),%xmm8		# s1+x2(s2+x2s3)
+	addpd	.Lsincosarray(%rip),%xmm9		# s1+x2(s2+x2s3)
+
+	movhlps	%xmm11,%xmm11				# move high x4 for cos term	+
+
+	mulpd	%xmm12,%xmm4				# x6(s4+x2(s5+x2s6))
+	mulpd	%xmm13,%xmm5				# x6(s4+x2(s5+x2s6))
+
+	movhlps	%xmm2,%xmm6				# move low x2 for x3 for sin term
+	movsd	%xmm3,%xmm7				# move low x2 for x3 for sin term   	+
+	mulsd	p_temp2+8(%rsp),%xmm6		# get low x3 for sin term
+	mulsd	%xmm1,%xmm7				# get low x3 for sin term		+
+
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for sin and cos terms
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for sin and cos terms
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm2,%xmm12				# move high 0.5*x2 for sin term
+	movhlps	%xmm3,%xmm13				# move high r for cos
+
+	movhlps	%xmm4,%xmm8				# xmm8 = sin , xmm4 = cos
+	movhlps	%xmm5,%xmm9				# xmm9 = cos , xmm5 = sin
+
+	mulsd	%xmm6,%xmm8				# sin *x3
+	mulsd	%xmm11,%xmm9				# cos *x4
+	mulsd	%xmm10,%xmm4				# cos *x4
+	mulsd	%xmm7,%xmm5				# sin *x3
+
+	mulsd	p_temp+8(%rsp),%xmm12		# 0.5 * x2 * xx for sin term
+	mulsd	p_temp1(%rsp),%xmm3		# 0.5 * x2 * xx for sin term
+
+	movsd	%xmm2,%xmm6				# Keep high r for cos term
+	movsd	%xmm13,%xmm7				# Keep high r for cos term
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm2 	#-t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13 	#-t=r-1.0
+
+	subsd	%xmm12,%xmm8				# sin - 0.5 * x2 *xx
+	subsd	%xmm3,%xmm5				# sin - 0.5 * x2 *xx
+
+	movhlps	%xmm0,%xmm10				# move high x for x for sin term
+	movhlps	%xmm1,%xmm11				# move high x for x*xx for cos term
+
+	mulsd	p_temp(%rsp),%xmm0		# x * xx
+	mulsd	p_temp1+8(%rsp),%xmm11		# x * xx
+
+	movsd	%xmm2,%xmm12				# move -t for cos term
+	movsd	%xmm13,%xmm3				# move -t for cos term
+
+	addsd	.L__real_3ff0000000000000(%rip),%xmm2 	# 1+(-t)
+	addsd	.L__real_3ff0000000000000(%rip),%xmm13	# 1+(-t)
+
+	addsd	p_temp+8(%rsp),%xmm8		# sin+xx
+	addsd	p_temp1(%rsp),%xmm5		# sin+xx
+
+	subsd	%xmm6,%xmm2				# (1-t) - r
+	subsd	%xmm7,%xmm13				# (1-t) - r
+
+	subsd	%xmm0,%xmm2				# ((1 + (-t)) - r) - x*xx
+	subsd	%xmm11,%xmm13				# ((1 + (-t)) - r) - x*xx
+
+
+	addsd	%xmm10,%xmm8				# sin + x
+	addsd	%xmm1,%xmm5				# sin + x
+
+	addsd   %xmm2,%xmm4				# cos+((1-t)-r - x*xx)
+	addsd   %xmm13,%xmm9				# cos+((1-t)-r - x*xx)
+
+	subsd   %xmm12,%xmm4				# cos+t
+	subsd   %xmm3,%xmm9				# cos+t
+
+	movlhps	%xmm8,%xmm4
+	movlhps	%xmm9,%xmm5
+	jmp 	.L__vrd4_sin_cleanup
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcoscos_sinsin_piby4:
+
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lsinarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lcosarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lsinarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lcosarray+0x20(%rip),%xmm9			# c3
+
+	movapd	 %xmm2,p_temp2(%rsp)			# store x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11	# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+	movapd	%xmm11,p_temp3(%rsp)			# store r
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	mulpd	%xmm2,%xmm10					# x4
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0
+
+	movapd	%xmm2,%xmm12					# copy of x2 for 0.5*x2
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lsinarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lcosarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lsinarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lcosarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm11	# 1 + (-t)
+
+	mulpd	%xmm2,%xmm10					# x6
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm12	# 0.5 *x2
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lsinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lcosarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm10,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm0,%xmm2					# x3 recalculate
+	mulpd	%xmm3,%xmm3					# x4 recalculate
+
+	movapd   p_temp3(%rsp),%xmm13			# r
+
+	mulpd	%xmm6,%xmm12					# 0.5 * x2 *xx
+	mulpd	%xmm1,%xmm7					# x * xx
+
+	subpd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm3,%xmm5					# x4 * zc
+
+	subpd	%xmm12,%xmm4					# -0.5 * x2 *xx
+	subpd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	addpd	%xmm6,%xmm4					# x3 * zs +xx
+	addpd   %xmm11,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm13	# t relaculate, -t = r-1
+	addpd	%xmm0,%xmm4					# +x
+	subpd   %xmm13,%xmm5					# + t
+
+	jmp	.L__vrd4_sin_cleanup
+
+.align 16
+.Lsinsin_coscos_piby4:
+
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lcosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lsinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lcosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lsinarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10	# r = 0.5 *x2
+	movapd	 %xmm3,p_temp3(%rsp)			# store x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+	movapd	 %xmm10,p_temp2(%rsp)			# store r
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0
+	mulpd	%xmm3,%xmm11					# x4
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for 0.5*x2
+
+	addpd	.Lcosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsinarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lcosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t)
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm11					# x6
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm13	# 0.5 *x2
+
+	addpd	.Lcosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lsinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm11,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zs
+
+	mulpd	%xmm2,%xmm2					# x4 recalculate
+	mulpd	%xmm1,%xmm3					# x3 recalculate
+
+	movapd   p_temp2(%rsp),%xmm12			# r
+
+	mulpd	%xmm0,%xmm6					# x * xx
+	mulpd	%xmm7,%xmm13					# 0.5 * x2 *xx
+	subpd   %xmm12,%xmm10					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x3 * zs
+
+	subpd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx;;;;;;;;;;;;;;;;;;;;;
+	subpd	%xmm13,%xmm5					# -0.5 * x2 *xx
+	addpd   %xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addpd	%xmm7,%xmm5					# +xx
+	subpd	.L__real_3ff0000000000000(%rip),%xmm12	# t relaculate, -t = r-1
+	addpd	%xmm1,%xmm5					# +x
+	subpd   %xmm12,%xmm4					# + t
+
+	jmp	.L__vrd4_sin_cleanup
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcoscos_cossin_piby4:				#Derive from cossin_coscos
+	movapd	%xmm2,%xmm10					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lsincosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lcosarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lsincosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lcosarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# r
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+	movapd	 %xmm6,p_temp(%rsp)			# rr
+	movhlps	 %xmm10,%xmm10					# get upper r for t for cos
+
+	mulpd	 %xmm2,%xmm8					# c3*x2
+	mulpd	 %xmm3,%xmm9					# c3*x2
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0  for cos
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lsincosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lcosarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lsincosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lcosarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addsd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t)
+	addpd   .L__real_3ff0000000000000(%rip),%xmm11	# 1 + (-t)
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lsincosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsincosarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lcosarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zc
+
+	movsd	%xmm0,%xmm8					# lower x for sin
+	mulsd	%xmm2,%xmm8					# lower x3 for sin
+
+	mulpd	%xmm2,%xmm2					# x4
+	mulpd	%xmm3,%xmm3					# upper x4 for cos
+	movsd	%xmm8,%xmm2					# lower x3 for sin
+
+	movsd	%xmm6,%xmm9					# lower xx
+								# note using odd reg
+
+	movlpd   p_temp2+8(%rsp),%xmm12		# upper r for cos term
+	movapd   p_temp3(%rsp),%xmm13			# r
+
+	mulpd	%xmm0,%xmm6					# x * xx for upper cos term
+	mulpd	%xmm1,%xmm7					# x * xx
+	movhlps	%xmm6,%xmm6
+	mulsd	p_temp2(%rsp),%xmm9 			# xx * 0.5*x2 for sin term
+
+	subsd   %xmm12,%xmm10					# (1 + (-t)) - r
+	subpd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x4 * zc
+								# x3 * zs
+
+	movhlps	%xmm4,%xmm8					# xmm8= cos, xmm4= sin
+
+	subsd	%xmm9,%xmm4					# x3zs - 0.5*x2*xx
+
+	subsd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx
+	subpd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	addsd   %xmm10,%xmm8					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addpd   %xmm11,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp(%rsp),%xmm4			# +xx
+
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12	# -t = r-1
+	subpd	.L__real_3ff0000000000000(%rip),%xmm13	# -t = r-1
+
+	subsd   %xmm12,%xmm8					# + t
+	addsd	%xmm0,%xmm4					# +x
+	subpd   %xmm13,%xmm5					# + t
+
+	movlhps	%xmm8,%xmm4
+
+	jmp	.L__vrd4_sin_cleanup
+
+.align 16
+.Lcoscos_sincos_piby4:		#Derive from sincos_coscos
+	movapd	%xmm2,%xmm10					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lcossinarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lcosarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lcossinarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lcosarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10	# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11	# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# r
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+	movapd	 %xmm6,p_temp(%rsp)			# rr
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0 for cos
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lcossinarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lcosarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lcossinarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lcosarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addsd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t) for cos
+	addpd   .L__real_3ff0000000000000(%rip),%xmm11	# 1 + (-t)
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lcossinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lcossinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lcosarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zszc
+	addpd	%xmm9,%xmm5					# z
+
+	mulpd	%xmm0,%xmm2					# upper x3 for sin
+	mulsd	%xmm0,%xmm2					# lower x4 for cos
+	mulpd	%xmm3,%xmm3					# x4
+
+	movhlps	%xmm6,%xmm9					# upper xx for sin term
+								# note using odd reg
+
+	movlpd  p_temp2(%rsp),%xmm12			# lower r for cos term
+	movapd  p_temp3(%rsp),%xmm13			# r
+
+
+	mulpd	%xmm0,%xmm6					# x * xx for lower cos term
+	mulpd	%xmm1,%xmm7					# x * xx
+
+	mulsd	p_temp2+8(%rsp),%xmm9 			# xx * 0.5*x2 for upper sin term
+
+	subsd   %xmm12,%xmm10					# (1 + (-t)) - r
+	subpd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# lower=x4 * zc
+								# upper=x3 * zs
+	mulpd	%xmm3,%xmm5
+								# x4 * zc
+
+	movhlps	%xmm4,%xmm8					# xmm8= sin, xmm4= cos
+	subsd	%xmm9,%xmm8					# x3zs - 0.5*x2*xx
+
+
+	subsd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx
+	subpd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	addsd   %xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addpd   %xmm11,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp+8(%rsp),%xmm8			# +xx
+
+	movhlps	%xmm0,%xmm0					# upper x for sin
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12	# -t = r-1
+	subpd	.L__real_3ff0000000000000(%rip),%xmm13	# -t = r-1
+
+	subsd   %xmm12,%xmm4					# + t
+	subpd   %xmm13,%xmm5					# + t
+	addsd	%xmm0,%xmm8					# +x
+
+	movlhps	%xmm8,%xmm4
+
+	jmp	.L__vrd4_sin_cleanup
+
+.align 16
+.Lcossin_coscos_piby4:
+	movapd	%xmm2,%xmm10					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lcosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lsincosarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lcosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lsincosarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# r
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+	movapd	 %xmm7,p_temp1(%rsp)			# rr
+	movhlps	%xmm11,%xmm11					# get upper r for t for cos
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0 for cos
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lcosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsincosarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lcosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsincosarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm10		# 1 + (-t)	;trash t
+	addsd   .L__real_3ff0000000000000(%rip),%xmm11		# 1 + (-t)	;trash t
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lcosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsincosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray(%rip),%xmm8				# c1 + x2(c2+x2C3)
+	addpd	.Lsincosarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zcs
+
+	movsd	%xmm1,%xmm9					# lower x for sin
+	mulsd	%xmm3,%xmm9					# lower x3 for sin
+
+	mulpd	%xmm2,%xmm2					# x4
+	mulpd	%xmm3,%xmm3					# upper x4 for cos
+	movsd	%xmm9,%xmm3					# lower x3 for sin
+
+	movsd	 %xmm7,%xmm8					# lower xx
+								# note using even reg
+
+	movapd   p_temp2(%rsp),%xmm12			# r
+	movlpd   p_temp3+8(%rsp),%xmm13		# upper r for cos term
+
+	mulpd	%xmm0,%xmm6					# x * xx
+	mulpd	%xmm1,%xmm7					# x * xx for upper cos term
+	movhlps	%xmm7,%xmm7
+	mulsd	p_temp3(%rsp),%xmm8 			# xx * 0.5*x2 for sin term
+
+	subpd   %xmm12,%xmm10					# (1 + (-t)) - r
+	subsd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x4 * zc
+								# x3 * zs
+
+	movhlps	%xmm5,%xmm9					# xmm9= cos, xmm5= sin
+
+	subsd	%xmm8,%xmm5					# x3zs - 0.5*x2*xx
+
+	subpd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx
+	subsd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	addpd   %xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd   %xmm11,%xmm9					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp1(%rsp),%xmm5			# +xx
+
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm12		# t relaculate, -t = r-1
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13		# t relaculate, -t = r-1
+
+	subpd   %xmm12,%xmm4					# + t
+	subsd   %xmm13,%xmm9					# + t
+	addsd	%xmm1,%xmm5					# +x
+
+	movlhps	%xmm9,%xmm5
+
+	jmp	.L__vrd4_sin_cleanup
+
+.align 16
+.Lcossin_sinsin_piby4:		# Derived from sincos_sinsin
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lsinarray+0x50(%rip),%xmm4				# c6
+	movdqa	.Lsincosarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lsinarray+0x20(%rip),%xmm8				# c3
+	movapd	.Lsincosarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+	movapd	 %xmm7,p_temp1(%rsp)			# rr
+
+	movhlps	%xmm11,%xmm11
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0 for cos
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lsinarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsincosarray+0x40(%rip),%xmm5		# c5+x2c6
+	addpd	.Lsinarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsincosarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	mulpd	%xmm6,%xmm10					# 0.5*x2*xx
+	addsd   .L__real_3ff0000000000000(%rip),%xmm11	# 1 + (-t) for cos
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lsinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsincosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lsincosarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zczs
+
+	movsd	%xmm3,%xmm12
+	mulsd	%xmm1,%xmm12					# low x3 for sin
+
+	mulpd	%xmm0, %xmm2					# x3
+	mulpd	%xmm3, %xmm3					# high x4 for cos
+	movsd	%xmm12,%xmm3					# low x3 for sin
+
+	movhlps	%xmm1,%xmm8					# upper x for cos term
+								# note using even reg
+	movlpd  p_temp3+8(%rsp),%xmm13			# upper r for cos term
+
+	mulsd	p_temp1+8(%rsp),%xmm8			# x * xx for upper cos term
+
+	mulsd	p_temp3(%rsp),%xmm7 			# xx * 0.5*x2 for lower sin term
+
+	subsd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm3,%xmm5					# lower=x4 * zc
+								# upper=x3 * zs
+
+	movhlps	%xmm5,%xmm9					# xmm9= cos, xmm5= sin
+
+	subsd	%xmm7,%xmm5					# x3zs - 0.5*x2*xx
+
+	subsd   %xmm8,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	subpd	%xmm10,%xmm4					# x3*zs - 0.5*x2*xx
+	addsd   %xmm11,%xmm9					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp1(%rsp),%xmm5			# +xx
+
+	addpd	%xmm6,%xmm4					# +xx
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13	# -t = r-1
+
+
+	addsd	%xmm1,%xmm5					# +x
+	addpd	%xmm0,%xmm4					# +x
+	subsd   %xmm13,%xmm9					# + t
+
+	movlhps	%xmm9,%xmm5
+
+	jmp	.L__vrd4_sin_cleanup
+
+.align 16
+.Lsincos_coscos_piby4:
+	movapd	%xmm2,%xmm10					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lcosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lcossinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lcosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lcossinarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# r
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+	movapd	 %xmm7,p_temp1(%rsp)			# rr
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0 for cos
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lcosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lcossinarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lcosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lcossinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t)
+	addsd   .L__real_3ff0000000000000(%rip),%xmm11	# 1 + (-t) for cos
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lcosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcossinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lcossinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zszc
+
+	mulpd	%xmm2,%xmm2					# x4
+	mulpd	%xmm1,%xmm3					# upper x3 for sin
+	mulsd	%xmm1,%xmm3					# lower x4 for cos
+
+	movhlps	%xmm7,%xmm8					# upper xx for sin term
+								# note using even reg
+
+	movapd  p_temp2(%rsp),%xmm12			# r
+	movlpd  p_temp3(%rsp),%xmm13			# lower r for cos term
+
+	mulpd	%xmm0,%xmm6					# x * xx
+	mulpd	%xmm1,%xmm7					# x * xx for lower cos term
+
+	mulsd	p_temp3+8(%rsp),%xmm8 			# xx * 0.5*x2 for upper sin term
+
+	subpd   %xmm12,%xmm10					# (1 + (-t)) - r
+	subsd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# lower=x4 * zc
+								# upper=x3 * zs
+
+	movhlps	%xmm5,%xmm9					# xmm9= sin, xmm5= cos
+
+	subsd	%xmm8,%xmm9					# x3zs - 0.5*x2*xx
+
+	subpd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx
+	subsd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	addpd   %xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd   %xmm11,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp1+8(%rsp),%xmm9				# +xx
+
+	movhlps	%xmm1,%xmm1					# upper x for sin
+	subpd	.L__real_3ff0000000000000(%rip),%xmm12		# -t = r-1
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13		# -t = r-1
+
+	subpd   %xmm12,%xmm4					# + t
+	subsd   %xmm13,%xmm5					# + t
+	addsd	%xmm1, %xmm9					# +x
+
+	movlhps	%xmm9, %xmm5
+
+	jmp	.L__vrd4_sin_cleanup
+
+
+.align 16
+.Lsincos_sinsin_piby4:		# Derived from sincos_coscos
+	movapd	%xmm2,%xmm10					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lsinarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lcossinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lsinarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lcossinarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+	movapd	 %xmm7,p_temp1(%rsp)			# rr
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0 for cos
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lsinarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lcossinarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lsinarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lcossinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	mulpd	%xmm6,%xmm10					# 0.5x2*xx
+	addsd   .L__real_3ff0000000000000(%rip),%xmm11	# 1 + (-t) for cos
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lsinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcossinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lcossinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zszc
+
+	mulpd	%xmm0,%xmm2					# x3
+	mulpd	%xmm1,%xmm3					# upper x3 for sin
+	mulsd	%xmm1,%xmm3					# lower x4 for cos
+
+	movhlps	%xmm7,%xmm8					# upper xx for sin term
+								# note using even reg
+
+	movlpd  p_temp3(%rsp),%xmm13			# lower r for cos term
+
+	mulpd	%xmm1,%xmm7					# x * xx for lower cos term
+
+	mulsd	p_temp3+8(%rsp),%xmm8 			# xx * 0.5*x2 for upper sin term
+
+	subsd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm3,%xmm5					# lower=x4 * zc
+								# upper=x3 * zs
+
+	movhlps	%xmm5,%xmm9					# xmm9= sin, xmm5= cos
+
+	subsd	%xmm8,%xmm9					# x3zs - 0.5*x2*xx
+
+	subsd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	subpd	%xmm10,%xmm4					# x3*zs - 0.5*x2*xx
+	addsd   %xmm11,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp1+8(%rsp),%xmm9			# +xx
+
+	movhlps	%xmm1,%xmm1					# upper x for sin
+	addpd	%xmm6,%xmm4					# +xx
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13	# -t = r-1
+
+	addsd	%xmm1,%xmm9					# +x
+	addpd	%xmm0,%xmm4					# +x
+	subsd   %xmm13,%xmm5					# + t
+
+	movlhps	%xmm9,%xmm5
+
+	jmp	.L__vrd4_sin_cleanup
+
+
+.align 16
+.Lsinsin_cossin_piby4:		# Derived from sincos_sinsin
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lsincosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lsinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lsincosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lsinarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10	# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11	# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# x2
+	movapd	 %xmm6,p_temp(%rsp)			# xx
+
+	movhlps	%xmm10,%xmm10
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0 for cos
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lsincosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsinarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lsincosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	mulpd	%xmm7,%xmm11					# 0.5*x2*xx
+	addsd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t) for cos
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lsincosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsincosarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lsinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zs
+
+
+	movsd	%xmm2,%xmm13
+	mulsd	%xmm0,%xmm13					# low x3 for sin
+
+	mulpd	%xmm1,%xmm3					# x3
+	mulpd	%xmm2,%xmm2					# high x4 for cos
+	movsd	%xmm13,%xmm2					# low x3 for sin
+
+
+	movhlps	%xmm0,%xmm9					# upper x for cos term								; note using even reg
+	movlpd  p_temp2+8(%rsp),%xmm12				# upper r for cos term
+	mulsd	p_temp+8(%rsp),%xmm9				# x * xx for upper cos term
+	mulsd	p_temp2(%rsp),%xmm6 				# xx * 0.5*x2 for lower sin term
+	subsd   %xmm12,%xmm10					# (1 + (-t)) - r
+	mulpd	%xmm3,%xmm5					# x3 * zs
+	mulpd	%xmm2,%xmm4					# lower=x4 * zc
+								# upper=x3 * zs
+
+	movhlps	%xmm4,%xmm8					# xmm8= cos, xmm4= sin
+	subsd	%xmm6,%xmm4					# x3zs - 0.5*x2*xx
+
+	subsd   %xmm9,%xmm10					# ((1 + (-t)) - r) - x*xx
+
+	subpd	%xmm11,%xmm5					# x3*zs - 0.5*x2*xx
+
+	addsd   %xmm10,%xmm8					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp(%rsp),%xmm4			# +xx
+
+	addpd	%xmm7,%xmm5					# +xx
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12	# -t = r-1
+
+	addsd	%xmm0,%xmm4					# +x
+	addpd	%xmm1,%xmm5					# +x
+	subsd   %xmm12,%xmm8					# + t
+	movlhps	%xmm8,%xmm4
+
+	jmp	.L__vrd4_sin_cleanup
+
+.align 16
+.Lsinsin_sincos_piby4:		# Derived from sincos_coscos
+
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lcossinarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lsinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lcossinarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lsinarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# r
+	movapd	 %xmm6,p_temp(%rsp)			# rr
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0 for cos
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lcossinarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsinarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lcossinarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	mulpd	%xmm7,%xmm11					# 0.5x2*xx
+	addsd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t) for cos
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lcossinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lcossinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lsinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zszc
+
+	mulpd	%xmm1,%xmm3					# x3
+	mulpd	%xmm0,%xmm2					# upper x3 for sin
+	mulsd	%xmm0,%xmm2					# lower x4 for cos
+
+	movhlps	%xmm6,%xmm9					# upper xx for sin term
+								# note using even reg
+
+	movlpd  p_temp2(%rsp),%xmm12			# lower r for cos term
+
+	mulpd	%xmm0,%xmm6					# x * xx for lower cos term
+
+	mulsd	p_temp2+8(%rsp),%xmm9 			# xx * 0.5*x2 for upper sin term
+
+	subsd   %xmm12,%xmm10					# (1 + (-t)) - r
+
+	mulpd	%xmm3,%xmm5					# x3 * zs
+	mulpd	%xmm2,%xmm4					# lower=x4 * zc
+								# upper=x3 * zs
+
+	movhlps	%xmm4,%xmm8					# xmm9= sin, xmm5= cos
+
+	subsd	%xmm9,%xmm8					# x3zs - 0.5*x2*xx
+
+	subsd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx
+
+	subpd	%xmm11,%xmm5					# x3*zs - 0.5*x2*xx
+	addsd   %xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp+8(%rsp),%xmm8			# +xx
+
+	movhlps	%xmm0,%xmm0					# upper x for sin
+	addpd	%xmm7,%xmm5					# +xx
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12	# -t = r-1
+
+
+	addsd	%xmm0,%xmm8					# +x
+	addpd	%xmm1,%xmm5					# +x
+	subsd   %xmm12,%xmm4					# + t
+
+	movlhps	%xmm8,%xmm4
+
+	jmp	.L__vrd4_sin_cleanup
+
+
+.align 16
+.Lsinsin_sinsin_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+#DEBUG
+#	xorpd   %xmm0, %xmm0
+#	xorpd   %xmm1, %xmm1
+#	jmp	.Lfinal_check
+#DEBUG
+
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lsinarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lsinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lsinarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lsinarray+0x20(%rip),%xmm9			# c3
+
+	movapd	 %xmm2,p_temp2(%rsp)			# copy of x2
+	movapd	 %xmm3,p_temp3(%rsp)			# copy of x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	mulpd	%xmm2,%xmm10					# x4
+	mulpd	%xmm3,%xmm11					# x4
+
+	addpd	.Lsinarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsinarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lsinarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	mulpd	%xmm2,%xmm10					# x6
+	mulpd	%xmm3,%xmm11					# x6
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm2		# 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm3		# 0.5 *x2
+
+	addpd	.Lsinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lsinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm6,%xmm2					# 0.5 * x2 *xx
+	mulpd	%xmm7,%xmm3					# 0.5 * x2 *xx
+
+	mulpd	%xmm10,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm11,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zs
+
+	movapd	p_temp2(%rsp),%xmm10			# x2
+	movapd	p_temp3(%rsp),%xmm11			# x2
+
+	mulpd	%xmm0,%xmm10					# x3
+	mulpd	%xmm1,%xmm11					# x3
+
+	mulpd	%xmm10,%xmm4					# x3 * zs
+	mulpd	%xmm11,%xmm5					# x3 * zs
+
+	subpd	%xmm2,%xmm4					# -0.5 * x2 *xx
+	subpd	%xmm3,%xmm5					# -0.5 * x2 *xx
+
+	addpd	%xmm6,%xmm4					# +xx
+	addpd	%xmm7,%xmm5					# +xx
+
+	addpd	%xmm0,%xmm4					# +x
+	addpd	%xmm1,%xmm5					# +x
+
+	jmp	.L__vrd4_sin_cleanup
diff --git a/src/gas/vrda_scaled_logr.S b/src/gas/vrda_scaled_logr.S
new file mode 100644
index 0000000..9d1bdc1
--- /dev/null
+++ b/src/gas/vrda_scaled_logr.S
@@ -0,0 +1,2428 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrda_scaled_logr.s
+#
+# An array implementation of the log libm function.
+#  Adapted to provide a scalingi and shifting factor.  This routine is
+#  used by the ACML RNG distribution functions.
+#
+# Prototype:
+#
+#    void vrda_scaled_logr(int n, double *x, double *y, double b);
+#
+#   Computes the natural log of x multiplied by a.
+# A reduced precision routine.   Uses the intel novel reduction technique
+# with frcpai to compute logs.
+#  Also uses only 3 polynomial terms to acheive52-18= 34 significant digits
+#
+#   This specialized routine does not handle negative numbers, 0, NaNs, or infinity.
+#   This routine is not C99 compliant
+#   This version can compute logs in 26
+#   cycles with n <= 24
+#
+#
+
+
+# define local variable storage offsets
+.equ	p_x,0			# temporary for error checking operation
+.equ	p_idx,0x010		# index storage
+.equ	p_xexp,0x020		# index storage
+
+.equ	p_x2,0x030		# temporary for error checking operation
+.equ	p_idx2,0x040		# index storage
+.equ	p_xexp2,0x050		# index storage
+
+.equ	save_xa,0x060		#qword
+.equ	save_ya,0x068		#qword
+.equ	save_nv,0x070		#qword
+.equ	p_iter,0x078		# qword	storage for number of loop iterations
+
+
+
+.equ	p2_temp,0x090		# second temporary for get/put bits operation
+
+.equ	stack_size,0x0e8
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+	.weak vrda_scaled_logr__
+	.set vrda_scaled_logr__,__vrda_scaled_logr__
+	.weak vrda_scaled_logr_
+	.set vrda_scaled_logr_,__vrda_scaled_logr__
+
+# Fortran interface parameters are passed in by Linux as:
+# rdi - int n
+# rsi - double *x
+# rdx - double *y
+# rcx - double *b
+
+    .text
+    .align 16
+    .p2align 4,,15
+
+#x/* a FORTRAN subroutine implementation of array log
+#**     VRDA_SCALED_LOG(N,X,Y,B)
+# C equivalent*/
+#void vrda_scaled_logr__(int * n, double *x, double *y,double *b)
+#{
+#       vrda_scaled_logr(*n,x,y,b);
+#}
+.globl __vrda_scaled_logr__
+    .type   __vrda_scaled_logr__,@function
+__vrda_scaled_logr__:
+    mov		(%rdi),%edi
+    movlpd	(%rcx),%xmm0
+
+# C interface parameters are passed in by Linux as:
+# rdi - int n
+# rsi - double *x
+# rdx - double *y
+# xmm0 - double b
+
+    .align 16
+    .p2align 4,,15
+.globl vrda_scaled_logr
+    .type   vrda_scaled_logr,@function
+vrda_scaled_logr:
+	sub		$stack_size,%rsp
+
+# save the arguments
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+	mov		%rdx,save_ya(%rsp)	# save y_array pointer
+#ifdef INTEGER64
+        mov             %rdi,%rax
+#else
+        mov             %edi,%eax
+        mov             %rax,%rdi
+#endif
+
+# move the scale and shift factor to another register
+	movsd		%xmm0,%xmm10
+	unpcklpd	%xmm10,%xmm10
+
+	mov		%rdi,save_nv(%rsp)	# save number of values
+# see if too few values to call the main loop
+	shr		$2,%rax			# get number of iterations
+	jz		.L__vda_cleanup		# jump if only single calls
+# prepare the iteration counts
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	shl		$2,%rax
+	sub		%rax,%rdi		# compute number of extra single calls
+	mov		%rdi,save_nv(%rsp)	# save number of left over values
+
+# In this second version, process the array 2 values at a time.
+
+.L__vda_top:
+# build the input _m128d
+	mov		save_xa(%rsp),%rsi	# get x_array pointer
+	movlpd	(%rsi),%xmm0
+	movhpd	8(%rsi),%xmm0
+	prefetch	64(%rsi)
+	add		$32,%rsi
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+
+                movlpd  -16(%rsi),%xmm1
+                movhpd  -8(%rsi),%xmm1
+
+# compute the logs
+
+#	movdqa	%xmm0,p_x(%rsp)	# save the input values
+
+# use the  algorithm referenced in the itanic trancendental paper.
+
+# reduction
+#  compute r = x frcpa(x) - 1
+        movdqa  %xmm0,%xmm8
+        movdqa  %xmm1,%xmm9
+
+        call    __vrd4_frcpa@PLT
+        movdqa  %xmm8,%xmm4
+                movdqa  %xmm9,%xmm7
+# invert the exponent
+        psllq   $1,%xmm8
+                psllq   $1,%xmm9
+        mulpd   %xmm0,%xmm4                             # r
+                mulpd   %xmm1,%xmm7                     # r
+        movdqa  %xmm8,%xmm5
+        paddq   .L__mask_rup(%rip),%xmm8
+        psrlq   $53,%xmm8
+                movdqa  %xmm9,%xmm6
+                paddq   .L__mask_rup(%rip),%xmm6
+                psrlq   $53,%xmm6
+        psubq   .L__mask_3ff(%rip),%xmm8
+                psubq   .L__mask_3ff(%rip),%xmm6
+        pshufd  $0x058,%xmm8,%xmm8
+                pshufd  $0x058,%xmm6,%xmm6
+
+
+        subpd   .L__real_one(%rip),%xmm4
+                subpd   .L__real_one(%rip),%xmm7
+
+        cvtdq2pd        %xmm8,%xmm0             #N
+                cvtdq2pd        %xmm6,%xmm1             #N
+#	movdqa	%xmm8,%xmm0
+#	movdqa	%xmm6,%xmm1
+# compute index for table lookup. if 1/2 bit set, increment the index+exponent
+        psrlq   $42,%xmm5
+                psrlq   $42,%xmm9
+        paddq   .L__int_one(%rip),%xmm5
+                paddq   .L__int_one(%rip),%xmm9
+        psrlq   $1,%xmm5
+                psrlq   $1,%xmm9
+        pand    .L__mask_3ff(%rip),%xmm5
+                pand    .L__mask_3ff(%rip),%xmm9
+        psllq   $1,%xmm5
+                psllq   $1,%xmm9
+
+        movdqa  %xmm5,p_x(%rsp) # move the indexes to a memory location
+                movdqa  %xmm9,p_x2(%rsp)
+
+
+        movapd  .L__real_third(%rip),%xmm3
+                movdqa  %xmm3,%xmm5
+        movapd  %xmm4,%xmm2
+                movapd  %xmm7,%xmm8
+
+# approximation
+#  compute the polynomial
+#   p(r) = p1r^2+p2r^3+p3r^4+p4r^5
+
+        mulpd   %xmm4,%xmm2                     #r^2
+                mulpd   %xmm7,%xmm8                     #r^2
+
+        mulpd   %xmm4,%xmm3                     # 1/3r
+                mulpd   %xmm7,%xmm5                     # 1/3r
+# lookup the f(k) term
+        lea             .L__np_lnf_table(%rip),%rdx
+        mov             p_x(%rsp),%rcx
+        mov             p_x+8(%rsp),%r9
+        movlpd          (%rdx,%rcx,8),%xmm6     # lookup
+        movhpd          (%rdx,%r9,8),%xmm6      # lookup
+
+        addpd   .L__real_half(%rip),%xmm3  # p2 + p3r
+                addpd   .L__real_half(%rip),%xmm5  # p2 + p3r
+
+                mov             p_x2(%rsp),%rcx
+                mov             p_x2+8(%rsp),%r9
+                movlpd          (%rdx,%rcx,8),%xmm9     # lookup
+                movhpd          (%rdx,%r9,8),%xmm9      # lookup
+
+        mulpd   %xmm3,%xmm2                     # r2(p2 + p3r)
+                mulpd   %xmm5,%xmm8                     # r2(p2 + p3r)
+        addpd   %xmm4,%xmm2                     # +r
+                addpd   %xmm7,%xmm8                     # +r
+
+
+#       reconstruction
+#  compute ln(x) = T + r + p(r) where
+#   T = N*ln(2)+ln(1/frcpa(x)) via tab of ln(1/frcpa(y)), where y = 1 + k/256, 0<=k<=255
+
+        mulpd   .L__real_log2(%rip),%xmm0        # compute  N*__real_log2
+                mulpd   .L__real_log2(%rip),%xmm1        # compute  N*__real_log2
+        addpd   %xmm6,%xmm2     # add the new mantissas
+                addpd   %xmm9,%xmm8     # add the new mantissas
+        addpd   %xmm2,%xmm0
+                addpd   %xmm8,%xmm1
+
+
+# store the result _m128d
+	mov		save_ya(%rsp),%rdi	# get y_array pointer
+	mulpd	%xmm10,%xmm0
+	movlpd	%xmm0,(%rdi)
+	movhpd	 %xmm0,8(%rdi)
+
+
+	prefetch	64(%rdi)
+	add		$32,%rdi
+	mov		%rdi,save_ya(%rsp)	# save y_array pointer
+
+# store the result _m128d
+		mulpd	%xmm10,%xmm1
+		movlpd	%xmm1,-16(%rdi)
+		movhpd	%xmm1,-8(%rdi)
+
+	mov		p_iter(%rsp),%rax	# get number of iterations
+	sub		$1,%rax
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	jnz		.L__vda_top
+
+
+# see if we need to do any extras
+	mov		save_nv(%rsp),%rax	# get number of values
+	test		%rax,%rax
+	jnz		.L__vda_cleanup
+
+
+.L__finish:
+	add		$stack_size,%rsp
+	ret
+
+	.align	16
+
+
+
+# we jump here when we have an odd number of log calls to make at the
+# end
+#  we assume that rdx is pointing at the next x array element,
+#  r8 at the next y array element.  The number of values left is in
+#  save_nv
+.L__vda_cleanup:
+        mov             save_nv(%rsp),%rax      # get number of values
+        test            %rax,%rax               # are there any values
+        jz              .L__finish              # exit if not
+
+	mov		save_xa(%rsp),%rsi
+	mov		save_ya(%rsp),%rdi
+
+# fill in a m128d with zeroes and the extra values and then make a recursive call.
+	xorpd		%xmm0,%xmm0
+	movlpd	%xmm0,p_x+8(%rsp)
+	movapd	%xmm0,p_x+16(%rsp)
+
+	mov		(%rsi),%rcx			# we know there's at least one
+	mov	 	%rcx,p_x(%rsp)
+	cmp		$2,%rax
+	jl		.L__vdacg
+
+	mov		8(%rsi),%rcx			# do the second value
+	mov	 	%rcx,p_x+8(%rsp)
+	cmp		$3,%rax
+	jl		.L__vdacg
+
+	mov		16(%rsi),%rcx			# do the third value
+	mov	 	%rcx,p_x+16(%rsp)
+
+.L__vdacg:
+	mov		$4,%rdi				# parameter for N
+	lea		p_x(%rsp),%rsi		# &x parameter
+	lea		p2_temp(%rsp),%rdx	# &y parameter
+	movsd		%xmm10,%xmm0
+	call		vrda_scaled_logr@PLT		# call recursively to compute four values
+
+# now copy the results to the destination array
+	mov		save_ya(%rsp),%rdi
+	mov		save_nv(%rsp),%rax	# get number of values
+	mov	 	p2_temp(%rsp),%rcx
+	mov		%rcx,(%rdi)			# we know there's at least one
+	cmp		$2,%rax
+	jl		.L__vdacgf
+
+	mov	 	p2_temp+8(%rsp),%rcx
+	mov		%rcx,8(%rdi)			# do the second value
+	cmp		$3,%rax
+	jl		.L__vdacgf
+
+	mov	 	p2_temp+16(%rsp),%rcx
+	mov		%rcx,16(%rdi)			# do the third value
+
+.L__vdacgf:
+	jmp		.L__finish
+
+	.data
+	.align	64
+
+.L__real_one:		.quad 0x03ff0000000000000	# 1.0
+			.quad 0x03ff0000000000000
+
+.L__real_half:		.quad 0x0bfe0000000000000	# 1/2
+			.quad 0x0bfe0000000000000
+.L__real_third:		.quad 0x03fd5555555555555	# 1/3
+			.quad 0x03fd5555555555555
+.L__real_fourth:	.quad 0x0bfd0000000000000	# 1/4
+			.quad 0x0bfd0000000000000
+
+.L__real_log2:	        .quad 0x03FE62E42FEFA39EF  # 0.693147182465
+		        .quad 0x03FE62E42FEFA39EF
+
+.L__mask_3ff:		.quad 0x000000000000003ff	#
+			.quad 0x000000000000003ff
+
+.L__mask_rup:           .quad 0x0000003fffffffffe
+                        .quad 0x0000003fffffffffe
+
+.L__int_one:		.quad 0x00000000000000001
+			.quad 0x00000000000000001
+
+
+
+
+.L__np_lnf_table:
+#log table Program - logtab.c
+#Built Jan 18 2006  09:51:57
+#Compiler version  1400
+
+    .quad 0x00000000000000000  # 0.000000000000 0
+    .quad 0x00000000000000000
+    .quad 0x03F50020055655885  # 0.000977039648 1
+    .quad 0x03F50020055655885
+    .quad 0x03F60040155D5881E  # 0.001955034836 2
+    .quad 0x03F60040155D5881E
+    .quad 0x03F6809048289860A  # 0.002933987435 3
+    .quad 0x03F6809048289860A
+    .quad 0x03F70080559588B25  # 0.003913899321 4
+    .quad 0x03F70080559588B25
+    .quad 0x03F740C8A7478788D  # 0.004894772377 5
+    .quad 0x03F740C8A7478788D
+    .quad 0x03F78121214586B02  # 0.005876608489 6
+    .quad 0x03F78121214586B02
+    .quad 0x03F7C189CBB0E283F  # 0.006859409551 7
+    .quad 0x03F7C189CBB0E283F
+    .quad 0x03F8010157588DE69  # 0.007843177461 8
+    .quad 0x03F8010157588DE69
+    .quad 0x03F82145E939EF1BC  # 0.008827914124 9
+    .quad 0x03F82145E939EF1BC
+    .quad 0x03F83D8896A83D7A8  # 0.009690354884 10
+    .quad 0x03F83D8896A83D7A8
+    .quad 0x03F85DDC705054DFF  # 0.010676913110 11
+    .quad 0x03F85DDC705054DFF
+    .quad 0x03F87E38762CA0C6D  # 0.011664445593 12
+    .quad 0x03F87E38762CA0C6D
+    .quad 0x03F89E9CAC6007563  # 0.012652954261 13
+    .quad 0x03F89E9CAC6007563
+    .quad 0x03F8BF091710935A4  # 0.013642441046 14
+    .quad 0x03F8BF091710935A4
+    .quad 0x03F8DF7DBA6777895  # 0.014632907884 15
+    .quad 0x03F8DF7DBA6777895
+    .quad 0x03F8FBEA8B13C03F9  # 0.015500371846 16
+    .quad 0x03F8FBEA8B13C03F9
+    .quad 0x03F90E3751F24F45C  # 0.016492681528 17
+    .quad 0x03F90E3751F24F45C
+    .quad 0x03F91E7D80B1FBF4C  # 0.017485976867 18
+    .quad 0x03F91E7D80B1FBF4C
+    .quad 0x03F92CBE4F6CC56C3  # 0.018355920375 19
+    .quad 0x03F92CBE4F6CC56C3
+    .quad 0x03F93D0C443D7258C  # 0.019351069108 20
+    .quad 0x03F93D0C443D7258C
+    .quad 0x03F94D5E6176ACC89  # 0.020347209148 21
+    .quad 0x03F94D5E6176ACC89
+    .quad 0x03F95DB4A937DEF10  # 0.021344342472 22
+    .quad 0x03F95DB4A937DEF10
+    .quad 0x03F96C039490E37F4  # 0.022217650494 23
+    .quad 0x03F96C039490E37F4
+    .quad 0x03F97C61B1CF5DED7  # 0.023216651576 24
+    .quad 0x03F97C61B1CF5DED7
+    .quad 0x03F98AB77B3FD6EAD  # 0.024091596947 25
+    .quad 0x03F98AB77B3FD6EAD
+    .quad 0x03F99B1D75828E780  # 0.025092472797 26
+    .quad 0x03F99B1D75828E780
+    .quad 0x03F9AB87A478CB7CB  # 0.026094351403 27
+    .quad 0x03F9AB87A478CB7CB
+    .quad 0x03F9B9E8027E1916F  # 0.026971819338 28
+    .quad 0x03F9B9E8027E1916F
+    .quad 0x03F9CA5A1A18613E6  # 0.027975583538 29
+    .quad 0x03F9CA5A1A18613E6
+    .quad 0x03F9D8C1670325921  # 0.028854704473 30
+    .quad 0x03F9D8C1670325921
+    .quad 0x03F9E93B6EE41F674  # 0.029860361378 31
+    .quad 0x03F9E93B6EE41F674
+    .quad 0x03F9F7A9B16782855  # 0.030741141554 32
+    .quad 0x03F9F7A9B16782855
+    .quad 0x03FA0415D89E74440  # 0.031748698315 33
+    .quad 0x03FA0415D89E74440
+    .quad 0x03FA0C58FA19DFAAB  # 0.032757271269 34
+    .quad 0x03FA0C58FA19DFAAB
+    .quad 0x03FA139577CC41C1A  # 0.033640607815 35
+    .quad 0x03FA139577CC41C1A
+    .quad 0x03FA1AD398C6CD57C  # 0.034524725334 36
+    .quad 0x03FA1AD398C6CD57C
+    .quad 0x03FA231C9C40E204E  # 0.035536103423 37
+    .quad 0x03FA231C9C40E204E
+    .quad 0x03FA2A5E4231CF7BD  # 0.036421899115 38
+    .quad 0x03FA2A5E4231CF7BD
+    .quad 0x03FA32AB4D4C59CB0  # 0.037435198758 39
+    .quad 0x03FA32AB4D4C59CB0
+    .quad 0x03FA39F07BA0EBD5A  # 0.038322679007 40
+    .quad 0x03FA39F07BA0EBD5A
+    .quad 0x03FA424192495D571  # 0.039337907520 41
+    .quad 0x03FA424192495D571
+    .quad 0x03FA498A4C73DA65D  # 0.040227078744 42
+    .quad 0x03FA498A4C73DA65D
+    .quad 0x03FA50D4AF75CA86F  # 0.041117041297 43
+    .quad 0x03FA50D4AF75CA86F
+    .quad 0x03FA592BBC15215BC  # 0.042135112141 44
+    .quad 0x03FA592BBC15215BC
+    .quad 0x03FA6079B00423FF6  # 0.043026775152 45
+    .quad 0x03FA6079B00423FF6
+    .quad 0x03FA67C94F2D4BB65  # 0.043919233935 46
+    .quad 0x03FA67C94F2D4BB65
+    .quad 0x03FA70265A550E77B  # 0.044940163069 47
+    .quad 0x03FA70265A550E77B
+    .quad 0x03FA77798F8D6DFDC  # 0.045834331871 48
+    .quad 0x03FA77798F8D6DFDC
+    .quad 0x03FA7ECE7267CD123  # 0.046729300926 49
+    .quad 0x03FA7ECE7267CD123
+    .quad 0x03FA873184BC09586  # 0.047753104446 50
+    .quad 0x03FA873184BC09586
+    .quad 0x03FA8E8A02D2E3175  # 0.048649793163 51
+    .quad 0x03FA8E8A02D2E3175
+    .quad 0x03FA95E430F8CE456  # 0.049547286652 52
+    .quad 0x03FA95E430F8CE456
+    .quad 0x03FA9D400FF482586  # 0.050445586359 53
+    .quad 0x03FA9D400FF482586
+    .quad 0x03FAA5AB21CB34A9E  # 0.051473203662 54
+    .quad 0x03FAA5AB21CB34A9E
+    .quad 0x03FAAD0AA2E784EF4  # 0.052373235867 55
+    .quad 0x03FAAD0AA2E784EF4
+    .quad 0x03FAB46BD74DA76A0  # 0.053274078860 56
+    .quad 0x03FAB46BD74DA76A0
+    .quad 0x03FABBCEBFC68F424  # 0.054175734102 57
+    .quad 0x03FABBCEBFC68F424
+    .quad 0x03FAC3335D1BBAE4D  # 0.055078203060 58
+    .quad 0x03FAC3335D1BBAE4D
+    .quad 0x03FACBA87200EB8F1  # 0.056110594428 59
+    .quad 0x03FACBA87200EB8F1
+    .quad 0x03FAD310BA20455A2  # 0.057014812019 60
+    .quad 0x03FAD310BA20455A2
+    .quad 0x03FADA7AB998B77ED  # 0.057919847959 61
+    .quad 0x03FADA7AB998B77ED
+    .quad 0x03FAE1E6713606CFB  # 0.058825703731 62
+    .quad 0x03FAE1E6713606CFB
+    .quad 0x03FAE953E1C48603A  # 0.059732380822 63
+    .quad 0x03FAE953E1C48603A
+    .quad 0x03FAF0C30C1116351  # 0.060639880722 64
+    .quad 0x03FAF0C30C1116351
+    .quad 0x03FAF833F0E927711  # 0.061548204926 65
+    .quad 0x03FAF833F0E927711
+    .quad 0x03FAFFA6911AB9309  # 0.062457354934 66
+    .quad 0x03FAFFA6911AB9309
+    .quad 0x03FB038D76BA2D737  # 0.063367332247 67
+    .quad 0x03FB038D76BA2D737
+    .quad 0x03FB0748836296412  # 0.064278138373 68
+    .quad 0x03FB0748836296412
+    .quad 0x03FB0B046EEE6F7A4  # 0.065189774824 69
+    .quad 0x03FB0B046EEE6F7A4
+    .quad 0x03FB0EC139C5DA5FD  # 0.066102243114 70
+    .quad 0x03FB0EC139C5DA5FD
+    .quad 0x03FB127EE451413A8  # 0.067015544762 71
+    .quad 0x03FB127EE451413A8
+    .quad 0x03FB163D6EF9579FC  # 0.067929681294 72
+    .quad 0x03FB163D6EF9579FC
+    .quad 0x03FB19FCDA271ABC0  # 0.068844654235 73
+    .quad 0x03FB19FCDA271ABC0
+    .quad 0x03FB1DBD2643D1912  # 0.069760465119 74
+    .quad 0x03FB1DBD2643D1912
+    .quad 0x03FB217E53B90D3CE  # 0.070677115481 75
+    .quad 0x03FB217E53B90D3CE
+    .quad 0x03FB254062F0A9417  # 0.071594606862 76
+    .quad 0x03FB254062F0A9417
+    .quad 0x03FB29035454CBCB0  # 0.072512940806 77
+    .quad 0x03FB29035454CBCB0
+    .quad 0x03FB2CC7284FE5F1A  # 0.073432118863 78
+    .quad 0x03FB2CC7284FE5F1A
+    .quad 0x03FB308BDF4CB4062  # 0.074352142586 79
+    .quad 0x03FB308BDF4CB4062
+    .quad 0x03FB345179B63DD3F  # 0.075273013532 80
+    .quad 0x03FB345179B63DD3F
+    .quad 0x03FB3817F7F7D6EAB  # 0.076194733263 81
+    .quad 0x03FB3817F7F7D6EAB
+    .quad 0x03FB3BDF5A7D1EE5E  # 0.077117303344 82
+    .quad 0x03FB3BDF5A7D1EE5E
+    .quad 0x03FB3F1D405CE86D3  # 0.077908755701 83
+    .quad 0x03FB3F1D405CE86D3
+    .quad 0x03FB42E64BEC266E4  # 0.078832909176 84
+    .quad 0x03FB42E64BEC266E4
+    .quad 0x03FB46B03CF437BC4  # 0.079757917501 85
+    .quad 0x03FB46B03CF437BC4
+    .quad 0x03FB4A7B13E1E3E65  # 0.080683782259 86
+    .quad 0x03FB4A7B13E1E3E65
+    .quad 0x03FB4E46D1223FE84  # 0.081610505036 87
+    .quad 0x03FB4E46D1223FE84
+    .quad 0x03FB52137522AE732  # 0.082538087426 88
+    .quad 0x03FB52137522AE732
+    .quad 0x03FB5555DE434F2A0  # 0.083333843436 89
+    .quad 0x03FB5555DE434F2A0
+    .quad 0x03FB59242FF043D34  # 0.084263026485 90
+    .quad 0x03FB59242FF043D34
+    .quad 0x03FB5CF36997817B2  # 0.085193073719 91
+    .quad 0x03FB5CF36997817B2
+    .quad 0x03FB60C38BA799459  # 0.086123986746 92
+    .quad 0x03FB60C38BA799459
+    .quad 0x03FB6408F471C82A2  # 0.086922602521 93
+    .quad 0x03FB6408F471C82A2
+    .quad 0x03FB67DAC7466CB96  # 0.087855127734 94
+    .quad 0x03FB67DAC7466CB96
+    .quad 0x03FB6BAD83C1883BA  # 0.088788523361 95
+    .quad 0x03FB6BAD83C1883BA
+    .quad 0x03FB6EF528C056A2D  # 0.089589270768 96
+    .quad 0x03FB6EF528C056A2D
+    .quad 0x03FB72C9985035BB1  # 0.090524287199 97
+    .quad 0x03FB72C9985035BB1
+    .quad 0x03FB769EF2C6B5688  # 0.091460178704 98
+    .quad 0x03FB769EF2C6B5688
+    .quad 0x03FB79E8D70A364C6  # 0.092263069152 99
+    .quad 0x03FB79E8D70A364C6
+    .quad 0x03FB7DBFE6EA733FE  # 0.093200590148 100
+    .quad 0x03FB7DBFE6EA733FE
+    .quad 0x03FB8197E2F40E3F0  # 0.094138990914 101
+    .quad 0x03FB8197E2F40E3F0
+    .quad 0x03FB84E40992A4804  # 0.094944035906 102
+    .quad 0x03FB84E40992A4804
+    .quad 0x03FB88BDBD5FC66D2  # 0.095884074919 103
+    .quad 0x03FB88BDBD5FC66D2
+    .quad 0x03FB8C985E9B9EC7E  # 0.096824998438 104
+    .quad 0x03FB8C985E9B9EC7E
+    .quad 0x03FB8FE6CAB20E979  # 0.097632209567 105
+    .quad 0x03FB8FE6CAB20E979
+    .quad 0x03FB93C3261014C65  # 0.098574780162 106
+    .quad 0x03FB93C3261014C65
+    .quad 0x03FB97130DC9235DE  # 0.099383405543 107
+    .quad 0x03FB97130DC9235DE
+    .quad 0x03FB9AF124D64C623  # 0.100327628989 108
+    .quad 0x03FB9AF124D64C623
+    .quad 0x03FB9E4289871E964  # 0.101137673586 109
+    .quad 0x03FB9E4289871E964
+    .quad 0x03FBA2225DD276FCB  # 0.102083555691 110
+    .quad 0x03FBA2225DD276FCB
+    .quad 0x03FBA57540D1FE441  # 0.102895024494 111
+    .quad 0x03FBA57540D1FE441
+    .quad 0x03FBA956D3ECADE60  # 0.103842571097 112
+    .quad 0x03FBA956D3ECADE60
+    .quad 0x03FBACAB3693AB9C0  # 0.104655469123 113
+    .quad 0x03FBACAB3693AB9C0
+    .quad 0x03FBB08E8A10F96F4  # 0.105604686090 114
+    .quad 0x03FBB08E8A10F96F4
+    .quad 0x03FBB3E46DBA02181  # 0.106419018383 115
+    .quad 0x03FBB3E46DBA02181
+    .quad 0x03FBB7C9832F58018  # 0.107369911615 116
+    .quad 0x03FBB7C9832F58018
+    .quad 0x03FBBB20E936D6976  # 0.108185683244 117
+    .quad 0x03FBBB20E936D6976
+    .quad 0x03FBBF07C23BC54EA  # 0.109138258671 118
+    .quad 0x03FBBF07C23BC54EA
+    .quad 0x03FBC260ABFFFE972  # 0.109955474734 119
+    .quad 0x03FBC260ABFFFE972
+    .quad 0x03FBC6494A2E418A0  # 0.110909738320 120
+    .quad 0x03FBC6494A2E418A0
+    .quad 0x03FBC9A3B90F57748  # 0.111728403941 121
+    .quad 0x03FBC9A3B90F57748
+    .quad 0x03FBCCFEDBFEE13A8  # 0.112547740324 122
+    .quad 0x03FBCCFEDBFEE13A8
+    .quad 0x03FBD0EA1362CDBFC  # 0.113504482008 123
+    .quad 0x03FBD0EA1362CDBFC
+    .quad 0x03FBD446BD753D433  # 0.114325275488 124
+    .quad 0x03FBD446BD753D433
+    .quad 0x03FBD7A41C8627307  # 0.115146743223 125
+    .quad 0x03FBD7A41C8627307
+    .quad 0x03FBDB91F09680DF9  # 0.116105975911 126
+    .quad 0x03FBDB91F09680DF9
+    .quad 0x03FBDEF0D8D466DBB  # 0.116928908339 127
+    .quad 0x03FBDEF0D8D466DBB
+    .quad 0x03FBE2507702AF03B  # 0.117752518544 128
+    .quad 0x03FBE2507702AF03B
+    .quad 0x03FBE640EB3D2B411  # 0.118714255240 129
+    .quad 0x03FBE640EB3D2B411
+    .quad 0x03FBE9A214A69DD58  # 0.119539337795 130
+    .quad 0x03FBE9A214A69DD58
+    .quad 0x03FBED03F4F440969  # 0.120365101673 131
+    .quad 0x03FBED03F4F440969
+    .quad 0x03FBF0F70CDD992E4  # 0.121329355484 132
+    .quad 0x03FBF0F70CDD992E4
+    .quad 0x03FBF45A7A78B7C3B  # 0.122156599431 133
+    .quad 0x03FBF45A7A78B7C3B
+    .quad 0x03FBF7BE9FEDBFDED  # 0.122984528276 134
+    .quad 0x03FBF7BE9FEDBFDED
+    .quad 0x03FBFB237D8AB13FB  # 0.123813143156 135
+    .quad 0x03FBFB237D8AB13FB
+    .quad 0x03FBFF1A13EAC95FD  # 0.124780729104 136
+    .quad 0x03FBFF1A13EAC95FD
+    .quad 0x03FC014040CAB0229  # 0.125610834299 137
+    .quad 0x03FC014040CAB0229
+    .quad 0x03FC02F3D4301417B  # 0.126441629140 138
+    .quad 0x03FC02F3D4301417B
+    .quad 0x03FC04A7C44CF87A4  # 0.127273114776 139
+    .quad 0x03FC04A7C44CF87A4
+    .quad 0x03FC06A4D1D26C5E9  # 0.128244055971 140
+    .quad 0x03FC06A4D1D26C5E9
+    .quad 0x03FC08598B59E3A07  # 0.129077042275 141
+    .quad 0x03FC08598B59E3A07
+    .quad 0x03FC0A0EA2164AF02  # 0.129910723024 142
+    .quad 0x03FC0A0EA2164AF02
+    .quad 0x03FC0BC4162F73B66  # 0.130745099376 143
+    .quad 0x03FC0BC4162F73B66
+    .quad 0x03FC0D79E7CD48E58  # 0.131580172493 144
+    .quad 0x03FC0D79E7CD48E58
+    .quad 0x03FC0F301717CF0FB  # 0.132415943541 145
+    .quad 0x03FC0F301717CF0FB
+    .quad 0x03FC10E6A437247B7  # 0.133252413686 146
+    .quad 0x03FC10E6A437247B7
+    .quad 0x03FC12E6BFA8FEAD6  # 0.134229180665 147
+    .quad 0x03FC12E6BFA8FEAD6
+    .quad 0x03FC149E189F8642E  # 0.135067169541 148
+    .quad 0x03FC149E189F8642E
+    .quad 0x03FC1655CFEA923A4  # 0.135905861231 149
+    .quad 0x03FC1655CFEA923A4
+    .quad 0x03FC180DE5B2ACE5C  # 0.136745256915 150
+    .quad 0x03FC180DE5B2ACE5C
+    .quad 0x03FC19C65A207AC07  # 0.137585357777 151
+    .quad 0x03FC19C65A207AC07
+    .quad 0x03FC1B7F2D5CBA842  # 0.138426165001 152
+    .quad 0x03FC1B7F2D5CBA842
+    .quad 0x03FC1D385F90453F2  # 0.139267679777 153
+    .quad 0x03FC1D385F90453F2
+    .quad 0x03FC1EF1F0E40E6CD  # 0.140109903297 154
+    .quad 0x03FC1EF1F0E40E6CD
+    .quad 0x03FC20ABE18124098  # 0.140952836755 155
+    .quad 0x03FC20ABE18124098
+    .quad 0x03FC22663190AEACC  # 0.141796481350 156
+    .quad 0x03FC22663190AEACC
+    .quad 0x03FC2420E13BF19E3  # 0.142640838281 157
+    .quad 0x03FC2420E13BF19E3
+    .quad 0x03FC25DBF0AC4AED2  # 0.143485908754 158
+    .quad 0x03FC25DBF0AC4AED2
+    .quad 0x03FC2797600B3387B  # 0.144331693975 159
+    .quad 0x03FC2797600B3387B
+    .quad 0x03FC29532F823F525  # 0.145178195155 160
+    .quad 0x03FC29532F823F525
+    .quad 0x03FC2B0F5F3B1D3EF  # 0.146025413505 161
+    .quad 0x03FC2B0F5F3B1D3EF
+    .quad 0x03FC2CCBEF5F97653  # 0.146873350243 162
+    .quad 0x03FC2CCBEF5F97653
+    .quad 0x03FC2E88E01993187  # 0.147722006588 163
+    .quad 0x03FC2E88E01993187
+    .quad 0x03FC3046319311009  # 0.148571383763 164
+    .quad 0x03FC3046319311009
+    .quad 0x03FC3203E3F62D328  # 0.149421482992 165
+    .quad 0x03FC3203E3F62D328
+    .quad 0x03FC33C1F76D1F469  # 0.150272305505 166
+    .quad 0x03FC33C1F76D1F469
+    .quad 0x03FC35806C223A70F  # 0.151123852534 167
+    .quad 0x03FC35806C223A70F
+    .quad 0x03FC373F423FED9A1  # 0.151976125313 168
+    .quad 0x03FC373F423FED9A1
+    .quad 0x03FC38FE79F0C3771  # 0.152829125080 169
+    .quad 0x03FC38FE79F0C3771
+    .quad 0x03FC3ABE135F62A12  # 0.153682853077 170
+    .quad 0x03FC3ABE135F62A12
+    .quad 0x03FC3C335E0447D71  # 0.154394850259 171
+    .quad 0x03FC3C335E0447D71
+    .quad 0x03FC3DF3AB13505F9  # 0.155249916579 172
+    .quad 0x03FC3DF3AB13505F9
+    .quad 0x03FC3FB45A59928CA  # 0.156105714663 173
+    .quad 0x03FC3FB45A59928CA
+    .quad 0x03FC41756C0220C81  # 0.156962245765 174
+    .quad 0x03FC41756C0220C81
+    .quad 0x03FC4336E03829D61  # 0.157819511141 175
+    .quad 0x03FC4336E03829D61
+    .quad 0x03FC44F8B726F8EFE  # 0.158677512051 176
+    .quad 0x03FC44F8B726F8EFE
+    .quad 0x03FC46BAF0F9F5DB8  # 0.159536249760 177
+    .quad 0x03FC46BAF0F9F5DB8
+    .quad 0x03FC48326CD3EC797  # 0.160252428262 178
+    .quad 0x03FC48326CD3EC797
+    .quad 0x03FC49F55C6502F81  # 0.161112520058 179
+    .quad 0x03FC49F55C6502F81
+    .quad 0x03FC4BB8AF55DE908  # 0.161973352249 180
+    .quad 0x03FC4BB8AF55DE908
+    .quad 0x03FC4D7C65D25566D  # 0.162834926111 181
+    .quad 0x03FC4D7C65D25566D
+    .quad 0x03FC4F4080065AA7F  # 0.163697242922 182
+    .quad 0x03FC4F4080065AA7F
+    .quad 0x03FC50B98CD30A759  # 0.164416408720 183
+    .quad 0x03FC50B98CD30A759
+    .quad 0x03FC527E5E4A1B58D  # 0.165280090939 184
+    .quad 0x03FC527E5E4A1B58D
+    .quad 0x03FC544393F5DF80F  # 0.166144519750 185
+    .quad 0x03FC544393F5DF80F
+    .quad 0x03FC56092E02BA514  # 0.167009696444 186
+    .quad 0x03FC56092E02BA514
+    .quad 0x03FC57837B3098F2C  # 0.167731249257 187
+    .quad 0x03FC57837B3098F2C
+    .quad 0x03FC5949CDB873419  # 0.168597800437 188
+    .quad 0x03FC5949CDB873419
+    .quad 0x03FC5B10851FC924A  # 0.169465103180 189
+    .quad 0x03FC5B10851FC924A
+    .quad 0x03FC5C8BC079D8289  # 0.170188430518 190
+    .quad 0x03FC5C8BC079D8289
+    .quad 0x03FC5E533144C1718  # 0.171057114516 191
+    .quad 0x03FC5E533144C1718
+    .quad 0x03FC601B076E7A8A8  # 0.171926553783 192
+    .quad 0x03FC601B076E7A8A8
+    .quad 0x03FC619732215D786  # 0.172651664394 193
+    .quad 0x03FC619732215D786
+    .quad 0x03FC635FC298F6C77  # 0.173522491735 194
+    .quad 0x03FC635FC298F6C77
+    .quad 0x03FC6528B8EFA5D16  # 0.174394078077 195
+    .quad 0x03FC6528B8EFA5D16
+    .quad 0x03FC66A5D42A3AD33  # 0.175120980777 196
+    .quad 0x03FC66A5D42A3AD33
+    .quad 0x03FC686F85BAD4298  # 0.175993962063 197
+    .quad 0x03FC686F85BAD4298
+    .quad 0x03FC6A399DABBD383  # 0.176867706111 198
+    .quad 0x03FC6A399DABBD383
+    .quad 0x03FC6BB7AA9F22C40  # 0.177596409780 199
+    .quad 0x03FC6BB7AA9F22C40
+    .quad 0x03FC6D827EB7C1E57  # 0.178471555693 200
+    .quad 0x03FC6D827EB7C1E57
+    .quad 0x03FC6F0128B756AB9  # 0.179201429458 201
+    .quad 0x03FC6F0128B756AB9
+    .quad 0x03FC70CCB9927BCF6  # 0.180077981742 202
+    .quad 0x03FC70CCB9927BCF6
+    .quad 0x03FC7298B1A4E32B6  # 0.180955303044 203
+    .quad 0x03FC7298B1A4E32B6
+    .quad 0x03FC74184F58CC7DC  # 0.181686992547 204
+    .quad 0x03FC74184F58CC7DC
+    .quad 0x03FC75E5051E74141  # 0.182565727226 205
+    .quad 0x03FC75E5051E74141
+    .quad 0x03FC77654128F6127  # 0.183298596442 206
+    .quad 0x03FC77654128F6127
+    .quad 0x03FC7932B53E97639  # 0.184178749058 207
+    .quad 0x03FC7932B53E97639
+    .quad 0x03FC7AB390229D8FD  # 0.184912801796 208
+    .quad 0x03FC7AB390229D8FD
+    .quad 0x03FC7C81C325B4A5E  # 0.185794376934 209
+    .quad 0x03FC7C81C325B4A5E
+    .quad 0x03FC7E033D66CD24A  # 0.186529617023 210
+    .quad 0x03FC7E033D66CD24A
+    .quad 0x03FC7FD22FF599D4C  # 0.187412619288 211
+    .quad 0x03FC7FD22FF599D4C
+    .quad 0x03FC81544A17F67C1  # 0.188149050576 212
+    .quad 0x03FC81544A17F67C1
+    .quad 0x03FC8323FCD17DAC8  # 0.189033484595 213
+    .quad 0x03FC8323FCD17DAC8
+    .quad 0x03FC84A6B759F512D  # 0.189771110947 214
+    .quad 0x03FC84A6B759F512D
+    .quad 0x03FC86772ADE0201C  # 0.190656981373 215
+    .quad 0x03FC86772ADE0201C
+    .quad 0x03FC87FA865210911  # 0.191395806674 216
+    .quad 0x03FC87FA865210911
+    .quad 0x03FC89CBBB4136201  # 0.192283118179 217
+    .quad 0x03FC89CBBB4136201
+    .quad 0x03FC8B4FB826FF291  # 0.193023146334 218
+    .quad 0x03FC8B4FB826FF291
+    .quad 0x03FC8D21AF2299298  # 0.193911903613 219
+    .quad 0x03FC8D21AF2299298
+    .quad 0x03FC8EA64E00E7FC0  # 0.194653138545 220
+    .quad 0x03FC8EA64E00E7FC0
+    .quad 0x03FC902B36AB7681D  # 0.195394923313 221
+    .quad 0x03FC902B36AB7681D
+    .quad 0x03FC91FE49096581E  # 0.196285791969 222
+    .quad 0x03FC91FE49096581E
+    .quad 0x03FC9383D471B869B  # 0.197028789254 223
+    .quad 0x03FC9383D471B869B
+    .quad 0x03FC9557AA6B87F65  # 0.197921115309 224
+    .quad 0x03FC9557AA6B87F65
+    .quad 0x03FC96DDD91A0B959  # 0.198665329082 225
+    .quad 0x03FC96DDD91A0B959
+    .quad 0x03FC9864522D04491  # 0.199410097121 226
+    .quad 0x03FC9864522D04491
+    .quad 0x03FC9A3945D1A44B3  # 0.200304551564 227
+    .quad 0x03FC9A3945D1A44B3
+    .quad 0x03FC9BC062F26FC3B  # 0.201050541900 228
+    .quad 0x03FC9BC062F26FC3B
+    .quad 0x03FC9D47CAD2C1871  # 0.201797089154 229
+    .quad 0x03FC9D47CAD2C1871
+    .quad 0x03FC9F1DDD7FE4F8B  # 0.202693682161 230
+    .quad 0x03FC9F1DDD7FE4F8B
+    .quad 0x03FCA0A5EA371A910  # 0.203441457564 231
+    .quad 0x03FCA0A5EA371A910
+    .quad 0x03FCA22E42098F498  # 0.204189792554 232
+    .quad 0x03FCA22E42098F498
+    .quad 0x03FCA405751F6CCE4  # 0.205088534376 233
+    .quad 0x03FCA405751F6CCE4
+    .quad 0x03FCA58E729348F40  # 0.205838103409 234
+    .quad 0x03FCA58E729348F40
+    .quad 0x03FCA717BB7EC64A3  # 0.206588234717 235
+    .quad 0x03FCA717BB7EC64A3
+    .quad 0x03FCA8F010601E5FD  # 0.207489135679 236
+    .quad 0x03FCA8F010601E5FD
+    .quad 0x03FCAA79FFB8FCD48  # 0.208240506966 237
+    .quad 0x03FCAA79FFB8FCD48
+    .quad 0x03FCAC043AE68965A  # 0.208992443238 238
+    .quad 0x03FCAC043AE68965A
+    .quad 0x03FCAD8EC205FB6AD  # 0.209744945343 239
+    .quad 0x03FCAD8EC205FB6AD
+    .quad 0x03FCAF6895610DBAD  # 0.210648695969 240
+    .quad 0x03FCAF6895610DBAD
+    .quad 0x03FCB0F3C3FBD65C9  # 0.211402445910 241
+    .quad 0x03FCB0F3C3FBD65C9
+    .quad 0x03FCB27F3EE674219  # 0.212156764419 242
+    .quad 0x03FCB27F3EE674219
+    .quad 0x03FCB40B063E65B0F  # 0.212911652354 243
+    .quad 0x03FCB40B063E65B0F
+    .quad 0x03FCB5E65A8096C88  # 0.213818270730 244
+    .quad 0x03FCB5E65A8096C88
+    .quad 0x03FCB772CA646760C  # 0.214574414434 245
+    .quad 0x03FCB772CA646760C
+    .quad 0x03FCB8FF871461198  # 0.215331130323 246
+    .quad 0x03FCB8FF871461198
+    .quad 0x03FCBA8C90AE4AD19  # 0.216088419265 247
+    .quad 0x03FCBA8C90AE4AD19
+    .quad 0x03FCBC19E74FFCBDA  # 0.216846282128 248
+    .quad 0x03FCBC19E74FFCBDA
+    .quad 0x03FCBDF71B83DAE7A  # 0.217756476365 249
+    .quad 0x03FCBDF71B83DAE7A
+    .quad 0x03FCBF851C067555C  # 0.218515604922 250
+    .quad 0x03FCBF851C067555C
+    .quad 0x03FCC11369F0CDB3C  # 0.219275310193 251
+    .quad 0x03FCC11369F0CDB3C
+    .quad 0x03FCC2A205610593E  # 0.220035593055 252
+    .quad 0x03FCC2A205610593E
+    .quad 0x03FCC430EE755023B  # 0.220796454387 253
+    .quad 0x03FCC430EE755023B
+    .quad 0x03FCC5C0254BF23A8  # 0.221557895069 254
+    .quad 0x03FCC5C0254BF23A8
+    .quad 0x03FCC79F9AB632BF1  # 0.222472389875 255
+    .quad 0x03FCC79F9AB632BF1
+    .quad 0x03FCC92F7D09ABE20  # 0.223235108240 256
+    .quad 0x03FCC92F7D09ABE20
+    .quad 0x03FCCABFAD80D023D  # 0.223998408788 257
+    .quad 0x03FCCABFAD80D023D
+    .quad 0x03FCCC502C3A2F1E8  # 0.224762292410 258
+    .quad 0x03FCCC502C3A2F1E8
+    .quad 0x03FCCDE0F9546A5E7  # 0.225526759995 259
+    .quad 0x03FCCDE0F9546A5E7
+    .quad 0x03FCCF7214EE356E9  # 0.226291812439 260
+    .quad 0x03FCCF7214EE356E9
+    .quad 0x03FCD1037F2655E7B  # 0.227057450635 261
+    .quad 0x03FCD1037F2655E7B
+    .quad 0x03FCD295381BA37E9  # 0.227823675483 262
+    .quad 0x03FCD295381BA37E9
+    .quad 0x03FCD4273FED08111  # 0.228590487882 263
+    .quad 0x03FCD4273FED08111
+    .quad 0x03FCD5B996B97FB5F  # 0.229357888733 264
+    .quad 0x03FCD5B996B97FB5F
+    .quad 0x03FCD74C3CA018C9C  # 0.230125878940 265
+    .quad 0x03FCD74C3CA018C9C
+    .quad 0x03FCD8DF31BFF3FF2  # 0.230894459410 266
+    .quad 0x03FCD8DF31BFF3FF2
+    .quad 0x03FCDA727638446A1  # 0.231663631050 267
+    .quad 0x03FCDA727638446A1
+    .quad 0x03FCDC56CAE452F5B  # 0.232587418645 268
+    .quad 0x03FCDC56CAE452F5B
+    .quad 0x03FCDDEABE5A3926E  # 0.233357894066 269
+    .quad 0x03FCDDEABE5A3926E
+    .quad 0x03FCDF7F018CE771F  # 0.234128963578 270
+    .quad 0x03FCDF7F018CE771F
+    .quad 0x03FCE113949BDEC62  # 0.234900628096 271
+    .quad 0x03FCE113949BDEC62
+    .quad 0x03FCE2A877A6B2C0F  # 0.235672888541 272
+    .quad 0x03FCE2A877A6B2C0F
+    .quad 0x03FCE43DAACD09BEC  # 0.236445745833 273
+    .quad 0x03FCE43DAACD09BEC
+    .quad 0x03FCE5D32E2E9CE87  # 0.237219200895 274
+    .quad 0x03FCE5D32E2E9CE87
+    .quad 0x03FCE76901EB38427  # 0.237993254653 275
+    .quad 0x03FCE76901EB38427
+    .quad 0x03FCE8ADE53F76866  # 0.238612929343 276
+    .quad 0x03FCE8ADE53F76866
+    .quad 0x03FCEA4449F04AAF4  # 0.239388063093 277
+    .quad 0x03FCEA4449F04AAF4
+    .quad 0x03FCEBDAFF5593E99  # 0.240163798141 278
+    .quad 0x03FCEBDAFF5593E99
+    .quad 0x03FCED72058F666C5  # 0.240940135421 279
+    .quad 0x03FCED72058F666C5
+    .quad 0x03FCEF095CBDE9937  # 0.241717075868 280
+    .quad 0x03FCEF095CBDE9937
+    .quad 0x03FCF0A1050157ED6  # 0.242494620422 281
+    .quad 0x03FCF0A1050157ED6
+    .quad 0x03FCF238FE79FF4BF  # 0.243272770021 282
+    .quad 0x03FCF238FE79FF4BF
+    .quad 0x03FCF3D1494840D2F  # 0.244051525609 283
+    .quad 0x03FCF3D1494840D2F
+    .quad 0x03FCF569E58C91077  # 0.244830888130 284
+    .quad 0x03FCF569E58C91077
+    .quad 0x03FCF702D36777DF0  # 0.245610858531 285
+    .quad 0x03FCF702D36777DF0
+    .quad 0x03FCF89C12F990D0C  # 0.246391437760 286
+    .quad 0x03FCF89C12F990D0C
+    .quad 0x03FCFA35A4638AE2C  # 0.247172626770 287
+    .quad 0x03FCFA35A4638AE2C
+    .quad 0x03FCFB7D86EEE3B92  # 0.247798017660 288
+    .quad 0x03FCFB7D86EEE3B92
+    .quad 0x03FCFD17ABFCDB683  # 0.248580306677 289
+    .quad 0x03FCFD17ABFCDB683
+    .quad 0x03FCFEB2233EA07CB  # 0.249363208150 290
+    .quad 0x03FCFEB2233EA07CB
+    .quad 0x03FD0026766A9671C  # 0.250146723037 291
+    .quad 0x03FD0026766A9671C
+    .quad 0x03FD00F40470C7323  # 0.250930852302 292
+    .quad 0x03FD00F40470C7323
+    .quad 0x03FD01C1BBC2735A3  # 0.251715596908 293
+    .quad 0x03FD01C1BBC2735A3
+    .quad 0x03FD028F9C7035C1D  # 0.252500957822 294
+    .quad 0x03FD028F9C7035C1D
+    .quad 0x03FD03346E0106062  # 0.253129690945 295
+    .quad 0x03FD03346E0106062
+    .quad 0x03FD0402994B4F041  # 0.253916163656 296
+    .quad 0x03FD0402994B4F041
+    .quad 0x03FD04D0EE20620AF  # 0.254703255393 297
+    .quad 0x03FD04D0EE20620AF
+    .quad 0x03FD059F6C910034D  # 0.255490967131 298
+    .quad 0x03FD059F6C910034D
+    .quad 0x03FD066E14ADF4BFD  # 0.256279299848 299
+    .quad 0x03FD066E14ADF4BFD
+    .quad 0x03FD07138604D5864  # 0.256910413785 300
+    .quad 0x03FD07138604D5864
+    .quad 0x03FD07E2794F3E8C1  # 0.257699866735 301
+    .quad 0x03FD07E2794F3E8C1
+    .quad 0x03FD08B196753A125  # 0.258489943414 302
+    .quad 0x03FD08B196753A125
+    .quad 0x03FD0980DD87BA2DD  # 0.259280644807 303
+    .quad 0x03FD0980DD87BA2DD
+    .quad 0x03FD0A504E97BB40C  # 0.260071971904 304
+    .quad 0x03FD0A504E97BB40C
+    .quad 0x03FD0AF660EB9E278  # 0.260705484754 305
+    .quad 0x03FD0AF660EB9E278
+    .quad 0x03FD0BC61DBBA97CB  # 0.261497940616 306
+    .quad 0x03FD0BC61DBBA97CB
+    .quad 0x03FD0C9604B8FC51E  # 0.262291024962 307
+    .quad 0x03FD0C9604B8FC51E
+    .quad 0x03FD0D3C7586CD5E5  # 0.262925945618 308
+    .quad 0x03FD0D3C7586CD5E5
+    .quad 0x03FD0E0CA89A72D29  # 0.263720163752 309
+    .quad 0x03FD0E0CA89A72D29
+    .quad 0x03FD0EDD060B78082  # 0.264515013170 310
+    .quad 0x03FD0EDD060B78082
+    .quad 0x03FD0FAD8DEB1E2C0  # 0.265310494876 311
+    .quad 0x03FD0FAD8DEB1E2C0
+    .quad 0x03FD10547F9D26ABC  # 0.265947336165 312
+    .quad 0x03FD10547F9D26ABC
+    .quad 0x03FD1125540925114  # 0.266743958529 313
+    .quad 0x03FD1125540925114
+    .quad 0x03FD11F653144CB8B  # 0.267541216005 314
+    .quad 0x03FD11F653144CB8B
+    .quad 0x03FD129DA43F5BE9E  # 0.268179479949 315
+    .quad 0x03FD129DA43F5BE9E
+    .quad 0x03FD136EF02E8290C  # 0.268977883185 316
+    .quad 0x03FD136EF02E8290C
+    .quad 0x03FD144066EDAE406  # 0.269776924378 317
+    .quad 0x03FD144066EDAE406
+    .quad 0x03FD14E817FF359D7  # 0.270416617347 318
+    .quad 0x03FD14E817FF359D7
+    .quad 0x03FD15B9DBFA9DEC8  # 0.271216809436 319
+    .quad 0x03FD15B9DBFA9DEC8
+    .quad 0x03FD168BCAF73B3EB  # 0.272017642345 320
+    .quad 0x03FD168BCAF73B3EB
+    .quad 0x03FD1733DC5D68DE8  # 0.272658770753 321
+    .quad 0x03FD1733DC5D68DE8
+    .quad 0x03FD180618EF18ADE  # 0.273460759729 322
+    .quad 0x03FD180618EF18ADE
+    .quad 0x03FD18D880B3826FE  # 0.274263392407 323
+    .quad 0x03FD18D880B3826FE
+    .quad 0x03FD1980F2DD42B6F  # 0.274905962710 324
+    .quad 0x03FD1980F2DD42B6F
+    .quad 0x03FD1A53A8902E70B  # 0.275709756661 325
+    .quad 0x03FD1A53A8902E70B
+    .quad 0x03FD1AFC59297024D  # 0.276353257326 326
+    .quad 0x03FD1AFC59297024D
+    .quad 0x03FD1BCF5D04AE1EA  # 0.277158215914 327
+    .quad 0x03FD1BCF5D04AE1EA
+    .quad 0x03FD1CA28C64BAE54  # 0.277963822983 328
+    .quad 0x03FD1CA28C64BAE54
+    .quad 0x03FD1D4B9E796C245  # 0.278608776246 329
+    .quad 0x03FD1D4B9E796C245
+    .quad 0x03FD1E1F1C5C3A06C  # 0.279415553216 330
+    .quad 0x03FD1E1F1C5C3A06C
+    .quad 0x03FD1EC86D5747AAD  # 0.280061443760 331
+    .quad 0x03FD1EC86D5747AAD
+    .quad 0x03FD1F9C39F74C559  # 0.280869394034 332
+    .quad 0x03FD1F9C39F74C559
+    .quad 0x03FD2070326F1F789  # 0.281677997620 333
+    .quad 0x03FD2070326F1F789
+    .quad 0x03FD2119E59F8789C  # 0.282325351583 334
+    .quad 0x03FD2119E59F8789C
+    .quad 0x03FD21EE2D300381C  # 0.283135133796 335
+    .quad 0x03FD21EE2D300381C
+    .quad 0x03FD22981FBEF797A  # 0.283783432036 336
+    .quad 0x03FD22981FBEF797A
+    .quad 0x03FD236CB6A339EED  # 0.284594396317 337
+    .quad 0x03FD236CB6A339EED
+    .quad 0x03FD2416E8C01F606  # 0.285243641592 338
+    .quad 0x03FD2416E8C01F606
+    .quad 0x03FD24EBCF3387FF6  # 0.286055791397 339
+    .quad 0x03FD24EBCF3387FF6
+    .quad 0x03FD2596410DF963A  # 0.286705986479 340
+    .quad 0x03FD2596410DF963A
+    .quad 0x03FD266B774C2AF55  # 0.287519325279 341
+    .quad 0x03FD266B774C2AF55
+    .quad 0x03FD27162913F873F  # 0.288170472950 342
+    .quad 0x03FD27162913F873F
+    .quad 0x03FD27EBAF58D8C9C  # 0.288985004232 343
+    .quad 0x03FD27EBAF58D8C9C
+    .quad 0x03FD2896A13E086A3  # 0.289637107288 344
+    .quad 0x03FD2896A13E086A3
+    .quad 0x03FD296C77C5C0E13  # 0.290452834554 345
+    .quad 0x03FD296C77C5C0E13
+    .quad 0x03FD2A17A9F88EDD2  # 0.291105895801 346
+    .quad 0x03FD2A17A9F88EDD2
+    .quad 0x03FD2AEDD0FF8CC2C  # 0.291922822568 347
+    .quad 0x03FD2AEDD0FF8CC2C
+    .quad 0x03FD2B9943B06BD77  # 0.292576844829 348
+    .quad 0x03FD2B9943B06BD77
+    .quad 0x03FD2C6FBB7360D0E  # 0.293394974630 349
+    .quad 0x03FD2C6FBB7360D0E
+    .quad 0x03FD2D1B6ED2FA90C  # 0.294049960734 350
+    .quad 0x03FD2D1B6ED2FA90C
+    .quad 0x03FD2DC73F01B0DD4  # 0.294705376127 351
+    .quad 0x03FD2DC73F01B0DD4
+    .quad 0x03FD2E9E2BCE12286  # 0.295525249913 352
+    .quad 0x03FD2E9E2BCE12286
+    .quad 0x03FD2F4A3CF22EDC2  # 0.296181633264 353
+    .quad 0x03FD2F4A3CF22EDC2
+    .quad 0x03FD30217B1006601  # 0.297002718785 354
+    .quad 0x03FD30217B1006601
+    .quad 0x03FD30CDCD5ABA762  # 0.297660072959 355
+    .quad 0x03FD30CDCD5ABA762
+    .quad 0x03FD31A55D07A8590  # 0.298482373803 356
+    .quad 0x03FD31A55D07A8590
+    .quad 0x03FD3251F0AA5CC1A  # 0.299140701674 357
+    .quad 0x03FD3251F0AA5CC1A
+    .quad 0x03FD32FEA167A6D70  # 0.299799463226 358
+    .quad 0x03FD32FEA167A6D70
+    .quad 0x03FD33D6A7509D491  # 0.300623525901 359
+    .quad 0x03FD33D6A7509D491
+    .quad 0x03FD348399ADA9D94  # 0.301283265328 360
+    .quad 0x03FD348399ADA9D94
+    .quad 0x03FD3530A9454ADC9  # 0.301943440298 361
+    .quad 0x03FD3530A9454ADC9
+    .quad 0x03FD360925EC44F5C  # 0.302769272371 362
+    .quad 0x03FD360925EC44F5C
+    .quad 0x03FD36B6776BE1116  # 0.303430429420 363
+    .quad 0x03FD36B6776BE1116
+    .quad 0x03FD378F469437FB4  # 0.304257490918 364
+    .quad 0x03FD378F469437FB4
+    .quad 0x03FD383CDA2E14ECB  # 0.304919632971 365
+    .quad 0x03FD383CDA2E14ECB
+    .quad 0x03FD38EA8B3924521  # 0.305582213748 366
+    .quad 0x03FD38EA8B3924521
+    .quad 0x03FD39C3D1FD60E74  # 0.306411057558 367
+    .quad 0x03FD39C3D1FD60E74
+    .quad 0x03FD3A71C56BB48C7  # 0.307074627589 368
+    .quad 0x03FD3A71C56BB48C7
+    .quad 0x03FD3B1FD66BC8D10  # 0.307738638238 369
+    .quad 0x03FD3B1FD66BC8D10
+    .quad 0x03FD3BF995502CB5C  # 0.308569272059 370
+    .quad 0x03FD3BF995502CB5C
+    .quad 0x03FD3CA7E8FD01DF6  # 0.309234276240 371
+    .quad 0x03FD3CA7E8FD01DF6
+    .quad 0x03FD3D565A5C5BF11  # 0.309899722945 372
+    .quad 0x03FD3D565A5C5BF11
+    .quad 0x03FD3E3091E6049FB  # 0.310732154526 373
+    .quad 0x03FD3E3091E6049FB
+    .quad 0x03FD3EDF463C1683E  # 0.311398599069 374
+    .quad 0x03FD3EDF463C1683E
+    .quad 0x03FD3F8E1865A82DD  # 0.312065488057 375
+    .quad 0x03FD3F8E1865A82DD
+    .quad 0x03FD403D086CEA79B  # 0.312732822082 376
+    .quad 0x03FD403D086CEA79B
+    .quad 0x03FD4117DE854CA15  # 0.313567616354 377
+    .quad 0x03FD4117DE854CA15
+    .quad 0x03FD41C711E4BA15E  # 0.314235953889 378
+    .quad 0x03FD41C711E4BA15E
+    .quad 0x03FD427663431B221  # 0.314904738398 379
+    .quad 0x03FD427663431B221
+    .quad 0x03FD4325D2AAB6F18  # 0.315573970480 380
+    .quad 0x03FD4325D2AAB6F18
+    .quad 0x03FD44014838E5513  # 0.316411140893 381
+    .quad 0x03FD44014838E5513
+    .quad 0x03FD44B0FB5AF4F44  # 0.317081382205 382
+    .quad 0x03FD44B0FB5AF4F44
+    .quad 0x03FD4560CCA7CB3B2  # 0.317752073041 383
+    .quad 0x03FD4560CCA7CB3B2
+    .quad 0x03FD4610BC29C5E18  # 0.318423214006 384
+    .quad 0x03FD4610BC29C5E18
+    .quad 0x03FD46ECD216CDCB5  # 0.319262774126 385
+    .quad 0x03FD46ECD216CDCB5
+    .quad 0x03FD479D05B65CB60  # 0.319934930091 386
+    .quad 0x03FD479D05B65CB60
+    .quad 0x03FD484D57ACE5A1A  # 0.320607538154 387
+    .quad 0x03FD484D57ACE5A1A
+    .quad 0x03FD48FDC804DD1CB  # 0.321280598924 388
+    .quad 0x03FD48FDC804DD1CB
+    .quad 0x03FD49DA7F3BCC420  # 0.322122562432 389
+    .quad 0x03FD49DA7F3BCC420
+    .quad 0x03FD4A8B341552B09  # 0.322796644021 390
+    .quad 0x03FD4A8B341552B09
+    .quad 0x03FD4B3C077267E9A  # 0.323471180303 391
+    .quad 0x03FD4B3C077267E9A
+    .quad 0x03FD4BECF95D97914  # 0.324146171892 392
+    .quad 0x03FD4BECF95D97914
+    .quad 0x03FD4C9E09E172C3D  # 0.324821619401 393
+    .quad 0x03FD4C9E09E172C3D
+    .quad 0x03FD4D4F3908901A0  # 0.325497523449 394
+    .quad 0x03FD4D4F3908901A0
+    .quad 0x03FD4E2CDF1F341C1  # 0.326343046455 395
+    .quad 0x03FD4E2CDF1F341C1
+    .quad 0x03FD4EDE535C79642  # 0.327019979972 396
+    .quad 0x03FD4EDE535C79642
+    .quad 0x03FD4F8FE65F90500  # 0.327697372039 397
+    .quad 0x03FD4F8FE65F90500
+    .quad 0x03FD5041983326F2D  # 0.328375223276 398
+    .quad 0x03FD5041983326F2D
+    .quad 0x03FD50F368E1F0F02  # 0.329053534308 399
+    .quad 0x03FD50F368E1F0F02
+    .quad 0x03FD51A55876A77F5  # 0.329732305758 400
+    .quad 0x03FD51A55876A77F5
+    .quad 0x03FD5283EF743F98B  # 0.330581418486 401
+    .quad 0x03FD5283EF743F98B
+    .quad 0x03FD533624B59CA35  # 0.331261228165 402
+    .quad 0x03FD533624B59CA35
+    .quad 0x03FD53E878FFE6EAE  # 0.331941500300 403
+    .quad 0x03FD53E878FFE6EAE
+    .quad 0x03FD549AEC5DEF880  # 0.332622235521 404
+    .quad 0x03FD549AEC5DEF880
+    .quad 0x03FD554D7EDA8D3C4  # 0.333303434457 405
+    .quad 0x03FD554D7EDA8D3C4
+    .quad 0x03FD560030809C759  # 0.333985097742 406
+    .quad 0x03FD560030809C759
+    .quad 0x03FD56B3015AFF52C  # 0.334667226008 407
+    .quad 0x03FD56B3015AFF52C
+    .quad 0x03FD5765F1749DA6C  # 0.335349819892 408
+    .quad 0x03FD5765F1749DA6C
+    .quad 0x03FD581900D864FD7  # 0.336032880027 409
+    .quad 0x03FD581900D864FD7
+    .quad 0x03FD58CC2F91489F5  # 0.336716407053 410
+    .quad 0x03FD58CC2F91489F5
+    .quad 0x03FD59AC5618CCE38  # 0.337571473373 411
+    .quad 0x03FD59AC5618CCE38
+    .quad 0x03FD5A5FCB795780C  # 0.338256053239 412
+    .quad 0x03FD5A5FCB795780C
+    .quad 0x03FD5B136052BCE39  # 0.338941102075 413
+    .quad 0x03FD5B136052BCE39
+    .quad 0x03FD5BC714B008E23  # 0.339626620526 414
+    .quad 0x03FD5BC714B008E23
+    .quad 0x03FD5C7AE89C4D254  # 0.340312609234 415
+    .quad 0x03FD5C7AE89C4D254
+    .quad 0x03FD5D2EDC22A12BA  # 0.340999068845 416
+    .quad 0x03FD5D2EDC22A12BA
+    .quad 0x03FD5DE2EF4E224D6  # 0.341686000008 417
+    .quad 0x03FD5DE2EF4E224D6
+    .quad 0x03FD5E972229F3C15  # 0.342373403369 418
+    .quad 0x03FD5E972229F3C15
+    .quad 0x03FD5F4B74C13EA04  # 0.343061279578 419
+    .quad 0x03FD5F4B74C13EA04
+    .quad 0x03FD5FFFE71F31E9A  # 0.343749629287 420
+    .quad 0x03FD5FFFE71F31E9A
+    .quad 0x03FD60B4794F02875  # 0.344438453147 421
+    .quad 0x03FD60B4794F02875
+    .quad 0x03FD61692B5BEB520  # 0.345127751813 422
+    .quad 0x03FD61692B5BEB520
+    .quad 0x03FD621DFD512D14F  # 0.345817525940 423
+    .quad 0x03FD621DFD512D14F
+    .quad 0x03FD62D2EF3A0E933  # 0.346507776183 424
+    .quad 0x03FD62D2EF3A0E933
+    .quad 0x03FD63880121DC8AB  # 0.347198503200 425
+    .quad 0x03FD63880121DC8AB
+    .quad 0x03FD643D3313E9B92  # 0.347889707652 426
+    .quad 0x03FD643D3313E9B92
+    .quad 0x03FD64F2851B8EE01  # 0.348581390197 427
+    .quad 0x03FD64F2851B8EE01
+    .quad 0x03FD65A7F7442AC90  # 0.349273551498 428
+    .quad 0x03FD65A7F7442AC90
+    .quad 0x03FD665D8999224A5  # 0.349966192218 429
+    .quad 0x03FD665D8999224A5
+    .quad 0x03FD67133C25E04A5  # 0.350659313022 430
+    .quad 0x03FD67133C25E04A5
+    .quad 0x03FD67C90EF5D5C4C  # 0.351352914576 431
+    .quad 0x03FD67C90EF5D5C4C
+    .quad 0x03FD687F021479CEE  # 0.352046997547 432
+    .quad 0x03FD687F021479CEE
+    .quad 0x03FD6935158D499B3  # 0.352741562603 433
+    .quad 0x03FD6935158D499B3
+    .quad 0x03FD69EB496BC87E5  # 0.353436610416 434
+    .quad 0x03FD69EB496BC87E5
+    .quad 0x03FD6AA19DBB7FF34  # 0.354132141656 435
+    .quad 0x03FD6AA19DBB7FF34
+    .quad 0x03FD6B581287FF9FD  # 0.354828156996 436
+    .quad 0x03FD6B581287FF9FD
+    .quad 0x03FD6C0EA7DCDD591  # 0.355524657112 437
+    .quad 0x03FD6C0EA7DCDD591
+    .quad 0x03FD6C97AD3CFCFD9  # 0.356047350738 438
+    .quad 0x03FD6C97AD3CFCFD9
+    .quad 0x03FD6D4E7B9C727EC  # 0.356744700836 439
+    .quad 0x03FD6D4E7B9C727EC
+    .quad 0x03FD6E056AA4421D6  # 0.357442537571 440
+    .quad 0x03FD6E056AA4421D6
+    .quad 0x03FD6EBC7A6019066  # 0.358140861621 441
+    .quad 0x03FD6EBC7A6019066
+    .quad 0x03FD6F73AADBAAAB7  # 0.358839673669 442
+    .quad 0x03FD6F73AADBAAAB7
+    .quad 0x03FD702AFC22B0C6D  # 0.359538974397 443
+    .quad 0x03FD702AFC22B0C6D
+    .quad 0x03FD70E26E40EB5FA  # 0.360238764489 444
+    .quad 0x03FD70E26E40EB5FA
+    .quad 0x03FD719A014220CF5  # 0.360939044629 445
+    .quad 0x03FD719A014220CF5
+    .quad 0x03FD7251B5321DC54  # 0.361639815506 446
+    .quad 0x03FD7251B5321DC54
+    .quad 0x03FD73098A1CB54BA  # 0.362341077807 447
+    .quad 0x03FD73098A1CB54BA
+    .quad 0x03FD73937F783CEBA  # 0.362867347444 448
+    .quad 0x03FD73937F783CEBA
+    .quad 0x03FD744B8E35E9EDA  # 0.363569471398 449
+    .quad 0x03FD744B8E35E9EDA
+    .quad 0x03FD7503BE0ED6C66  # 0.364272088676 450
+    .quad 0x03FD7503BE0ED6C66
+    .quad 0x03FD75BC0F0EEE7DE  # 0.364975199972 451
+    .quad 0x03FD75BC0F0EEE7DE
+    .quad 0x03FD76748142228C7  # 0.365678805982 452
+    .quad 0x03FD76748142228C7
+    .quad 0x03FD772D14B46AE00  # 0.366382907402 453
+    .quad 0x03FD772D14B46AE00
+    .quad 0x03FD77E5C971C5E06  # 0.367087504930 454
+    .quad 0x03FD77E5C971C5E06
+    .quad 0x03FD787066E04915F  # 0.367616279067 455
+    .quad 0x03FD787066E04915F
+    .quad 0x03FD792955FDF47A3  # 0.368321746469 456
+    .quad 0x03FD792955FDF47A3
+    .quad 0x03FD79E26687CFB3D  # 0.369027711906 457
+    .quad 0x03FD79E26687CFB3D
+    .quad 0x03FD7A9B9889F19E2  # 0.369734176082 458
+    .quad 0x03FD7A9B9889F19E2
+    .quad 0x03FD7B54EC1077A48  # 0.370441139703 459
+    .quad 0x03FD7B54EC1077A48
+    .quad 0x03FD7C0E612785C74  # 0.371148603475 460
+    .quad 0x03FD7C0E612785C74
+    .quad 0x03FD7C998F06FB152  # 0.371679529954 461
+    .quad 0x03FD7C998F06FB152
+    .quad 0x03FD7D533EF841E8A  # 0.372387870696 462
+    .quad 0x03FD7D533EF841E8A
+    .quad 0x03FD7E0D109B95F19  # 0.373096713539 463
+    .quad 0x03FD7E0D109B95F19
+    .quad 0x03FD7EC703FD340AA  # 0.373806059198 464
+    .quad 0x03FD7EC703FD340AA
+    .quad 0x03FD7F8119295FB9B  # 0.374515908385 465
+    .quad 0x03FD7F8119295FB9B
+    .quad 0x03FD800CBF3ED1CC2  # 0.375048626146 466
+    .quad 0x03FD800CBF3ED1CC2
+    .quad 0x03FD80C70FAB0BDF6  # 0.375759358229 467
+    .quad 0x03FD80C70FAB0BDF6
+    .quad 0x03FD81818203AFC7F  # 0.376470595813 468
+    .quad 0x03FD81818203AFC7F
+    .quad 0x03FD823C16551A3C3  # 0.377182339615 469
+    .quad 0x03FD823C16551A3C3
+    .quad 0x03FD82C81BE4DFF4A  # 0.377716480107 470
+    .quad 0x03FD82C81BE4DFF4A
+    .quad 0x03FD8382EBC7794D1  # 0.378429111528 471
+    .quad 0x03FD8382EBC7794D1
+    .quad 0x03FD843DDDC4FB137  # 0.379142251156 472
+    .quad 0x03FD843DDDC4FB137
+    .quad 0x03FD84F8F1E9DB72B  # 0.379855899714 473
+    .quad 0x03FD84F8F1E9DB72B
+    .quad 0x03FD85855776DCBFB  # 0.380391470556 474
+    .quad 0x03FD85855776DCBFB
+    .quad 0x03FD8640A77EB3957  # 0.381106011494 475
+    .quad 0x03FD8640A77EB3957
+    .quad 0x03FD86FC19D05148E  # 0.381821063366 476
+    .quad 0x03FD86FC19D05148E
+    .quad 0x03FD87B7AE7845C0F  # 0.382536626902 477
+    .quad 0x03FD87B7AE7845C0F
+    .quad 0x03FD8844748678822  # 0.383073635776 478
+    .quad 0x03FD8844748678822
+    .quad 0x03FD89004563D3DFD  # 0.383790096491 479
+    .quad 0x03FD89004563D3DFD
+    .quad 0x03FD89BC38BA356B4  # 0.384507070890 480
+    .quad 0x03FD89BC38BA356B4
+    .quad 0x03FD8A4945E20894E  # 0.385045139237 481
+    .quad 0x03FD8A4945E20894E
+    .quad 0x03FD8B0575AAB1FC5  # 0.385763014358 482
+    .quad 0x03FD8B0575AAB1FC5
+    .quad 0x03FD8BC1C80F45A32  # 0.386481405193 483
+    .quad 0x03FD8BC1C80F45A32
+    .quad 0x03FD8C7E3D1C80B2F  # 0.387200312485 484
+    .quad 0x03FD8C7E3D1C80B2F
+    .quad 0x03FD8D0BABACC89EE  # 0.387739832326 485
+    .quad 0x03FD8D0BABACC89EE
+    .quad 0x03FD8DC85D7FE5013  # 0.388459645206 486
+    .quad 0x03FD8DC85D7FE5013
+    .quad 0x03FD8E85321ED5598  # 0.389179976589 487
+    .quad 0x03FD8E85321ED5598
+    .quad 0x03FD8F12E873862C7  # 0.389720565845 488
+    .quad 0x03FD8F12E873862C7
+    .quad 0x03FD8FCFFA1614AA0  # 0.390441806410 489
+    .quad 0x03FD8FCFFA1614AA0
+    .quad 0x03FD908D2EA7D9511  # 0.391163567538 490
+    .quad 0x03FD908D2EA7D9511
+    .quad 0x03FD911B2D09ED9D6  # 0.391705230456 491
+    .quad 0x03FD911B2D09ED9D6
+    .quad 0x03FD91D89EDD6B7FF  # 0.392427904381 492
+    .quad 0x03FD91D89EDD6B7FF
+    .quad 0x03FD929633C3B7D3E  # 0.393151100941 493
+    .quad 0x03FD929633C3B7D3E
+    .quad 0x03FD93247A7C99B52  # 0.393693841796 494
+    .quad 0x03FD93247A7C99B52
+    .quad 0x03FD93E24CE3195E8  # 0.394417954789 495
+    .quad 0x03FD93E24CE3195E8
+    .quad 0x03FD9470C1CB1962E  # 0.394961383840 496
+    .quad 0x03FD9470C1CB1962E
+    .quad 0x03FD952ED1D9C0435  # 0.395686415592 497
+    .quad 0x03FD952ED1D9C0435
+    .quad 0x03FD95ED0535EA5D9  # 0.396411973396 498
+    .quad 0x03FD95ED0535EA5D9
+    .quad 0x03FD967BC2EDCCE17  # 0.396956487431 499
+    .quad 0x03FD967BC2EDCCE17
+    .quad 0x03FD973A3431356AE  # 0.397682967666 500
+    .quad 0x03FD973A3431356AE
+    .quad 0x03FD97F8C8E64A1C7  # 0.398409976059 501
+    .quad 0x03FD97F8C8E64A1C7
+    .quad 0x03FD9887CFB8A3932  # 0.398955579419 502
+    .quad 0x03FD9887CFB8A3932
+    .quad 0x03FD9946A2946EF3C  # 0.399683513937 503
+    .quad 0x03FD9946A2946EF3C
+    .quad 0x03FD99D5D8130607C  # 0.400229812776 504
+    .quad 0x03FD99D5D8130607C
+    .quad 0x03FD9A94E93E1EC37  # 0.400958675782 505
+    .quad 0x03FD9A94E93E1EC37
+    .quad 0x03FD9B244D87735E8  # 0.401505671875 506
+    .quad 0x03FD9B244D87735E8
+    .quad 0x03FD9BE39D2A97F0B  # 0.402235465741 507
+    .quad 0x03FD9BE39D2A97F0B
+    .quad 0x03FD9CA3109266E23  # 0.402965792595 508
+    .quad 0x03FD9CA3109266E23
+    .quad 0x03FD9D32BEA15ED3A  # 0.403513887977 509
+    .quad 0x03FD9D32BEA15ED3A
+    .quad 0x03FD9DF270C1914A8  # 0.404245149435 510
+    .quad 0x03FD9DF270C1914A8
+    .quad 0x03FD9E824DEA3E135  # 0.404793946669 511
+    .quad 0x03FD9E824DEA3E135
+    .quad 0x03FD9F423EEBF9DA1  # 0.405526145127 512
+    .quad 0x03FD9F423EEBF9DA1
+    .quad 0x03FD9FD24B4D47012  # 0.406075646011 513
+    .quad 0x03FD9FD24B4D47012
+    .quad 0x03FDA0927B59DA6E2  # 0.406808783874 514
+    .quad 0x03FDA0927B59DA6E2
+    .quad 0x03FDA152CF7F3B46D  # 0.407542459622 515
+    .quad 0x03FDA152CF7F3B46D
+    .quad 0x03FDA1E32653B420E  # 0.408093069896 516
+    .quad 0x03FDA1E32653B420E
+    .quad 0x03FDA2A3B9C527DB1  # 0.408827688845 517
+    .quad 0x03FDA2A3B9C527DB1
+    .quad 0x03FDA33440224FA79  # 0.409379007429 518
+    .quad 0x03FDA33440224FA79
+    .quad 0x03FDA3F513098DD09  # 0.410114572008 519
+    .quad 0x03FDA3F513098DD09
+    .quad 0x03FDA485C90EBDB0C  # 0.410666600728 520
+    .quad 0x03FDA485C90EBDB0C
+    .quad 0x03FDA546DB95A721A  # 0.411403113374 521
+    .quad 0x03FDA546DB95A721A
+    .quad 0x03FDA5D7C16257437  # 0.411955854060 522
+    .quad 0x03FDA5D7C16257437
+    .quad 0x03FDA69913B2F6572  # 0.412693317221 523
+    .quad 0x03FDA69913B2F6572
+    .quad 0x03FDA72A2966BE1EA  # 0.413246771713 524
+    .quad 0x03FDA72A2966BE1EA
+    .quad 0x03FDA7EBBBAB46E8B  # 0.413985187844 525
+    .quad 0x03FDA7EBBBAB46E8B
+    .quad 0x03FDA87D0165DD199  # 0.414539357989 526
+    .quad 0x03FDA87D0165DD199
+    .quad 0x03FDA93ED3C8AD9E3  # 0.415278729556 527
+    .quad 0x03FDA93ED3C8AD9E3
+    .quad 0x03FDA9D049A9E884A  # 0.415833617206 528
+    .quad 0x03FDA9D049A9E884A
+    .quad 0x03FDAA925C5588EFA  # 0.416573946686 529
+    .quad 0x03FDAA925C5588EFA
+    .quad 0x03FDAB24027D5E8AF  # 0.417129553701 530
+    .quad 0x03FDAB24027D5E8AF
+    .quad 0x03FDABE6559C8167C  # 0.417870843580 531
+    .quad 0x03FDABE6559C8167C
+    .quad 0x03FDAC782C2B07944  # 0.418427171828 532
+    .quad 0x03FDAC782C2B07944
+    .quad 0x03FDAD3ABFE88A06E  # 0.419169424599 533
+    .quad 0x03FDAD3ABFE88A06E
+    .quad 0x03FDADCCC6FDF6A80  # 0.419726475955 534
+    .quad 0x03FDADCCC6FDF6A80
+    .quad 0x03FDAE5EE2E961227  # 0.420283837790 535
+    .quad 0x03FDAE5EE2E961227
+    .quad 0x03FDAF21D34189D0A  # 0.421027470470 536
+    .quad 0x03FDAF21D34189D0A
+    .quad 0x03FDAFB41FE2167B4  # 0.421585558104 537
+    .quad 0x03FDAFB41FE2167B4
+    .quad 0x03FDB07751416A7F3  # 0.422330159776 538
+    .quad 0x03FDB07751416A7F3
+    .quad 0x03FDB109CEB79DB8A  # 0.422888975102 539
+    .quad 0x03FDB109CEB79DB8A
+    .quad 0x03FDB1CD41498DF12  # 0.423634548296 540
+    .quad 0x03FDB1CD41498DF12
+    .quad 0x03FDB25FEFB60CB2E  # 0.424194093214 541
+    .quad 0x03FDB25FEFB60CB2E
+    .quad 0x03FDB323A3A63594A  # 0.424940640468 542
+    .quad 0x03FDB323A3A63594A
+    .quad 0x03FDB3B68329C59E9  # 0.425500916886 543
+    .quad 0x03FDB3B68329C59E9
+    .quad 0x03FDB44977C148F1A  # 0.426061507389 544
+    .quad 0x03FDB44977C148F1A
+    .quad 0x03FDB50D895F7773A  # 0.426809450580 545
+    .quad 0x03FDB50D895F7773A
+    .quad 0x03FDB5A0AF3D169CD  # 0.427370775322 546
+    .quad 0x03FDB5A0AF3D169CD
+    .quad 0x03FDB66502A41E541  # 0.428119698779 547
+    .quad 0x03FDB66502A41E541
+    .quad 0x03FDB6F859E8EF639  # 0.428681759684 548
+    .quad 0x03FDB6F859E8EF639
+    .quad 0x03FDB78BC664238C0  # 0.429244136679 549
+    .quad 0x03FDB78BC664238C0
+    .quad 0x03FDB85078123E586  # 0.429994464983 550
+    .quad 0x03FDB85078123E586
+    .quad 0x03FDB8E41624226C5  # 0.430557580905 551
+    .quad 0x03FDB8E41624226C5
+    .quad 0x03FDB9A90A06BCB3D  # 0.431308895742 552
+    .quad 0x03FDB9A90A06BCB3D
+    .quad 0x03FDBA3CD9D0B81BD  # 0.431872752537 553
+    .quad 0x03FDBA3CD9D0B81BD
+    .quad 0x03FDBAD0BEF3DB164  # 0.432436927446 554
+    .quad 0x03FDBAD0BEF3DB164
+    .quad 0x03FDBB9611B80E2FC  # 0.433189656123 555
+    .quad 0x03FDBB9611B80E2FC
+    .quad 0x03FDBC2A28C33B75D  # 0.433754574696 556
+    .quad 0x03FDBC2A28C33B75D
+    .quad 0x03FDBCBE553C2BDDF  # 0.434319812582 557
+    .quad 0x03FDBCBE553C2BDDF
+    .quad 0x03FDBD84073D8EC2B  # 0.435073960430 558
+    .quad 0x03FDBD84073D8EC2B
+    .quad 0x03FDBE1865CEC1EC9  # 0.435639944787 559
+    .quad 0x03FDBE1865CEC1EC9
+    .quad 0x03FDBEACD9E271AD1  # 0.436206249662 560
+    .quad 0x03FDBEACD9E271AD1
+    .quad 0x03FDBF72EB7D20355  # 0.436961822044 561
+    .quad 0x03FDBF72EB7D20355
+    .quad 0x03FDC00791D99132B  # 0.437528876213 562
+    .quad 0x03FDC00791D99132B
+    .quad 0x03FDC09C4DCD565AB  # 0.438096252115 563
+    .quad 0x03FDC09C4DCD565AB
+    .quad 0x03FDC162BF5DF23E4  # 0.438853254422 564
+    .quad 0x03FDC162BF5DF23E4
+    .quad 0x03FDC1F7ADCB3DAB0  # 0.439421382456 565
+    .quad 0x03FDC1F7ADCB3DAB0
+    .quad 0x03FDC28CB1E4D32FD  # 0.439989833442 566
+    .quad 0x03FDC28CB1E4D32FD
+    .quad 0x03FDC35383C8850B0  # 0.440748271097 567
+    .quad 0x03FDC35383C8850B0
+    .quad 0x03FDC3E8BA8CACF27  # 0.441317477070 568
+    .quad 0x03FDC3E8BA8CACF27
+    .quad 0x03FDC47E071233744  # 0.441887007223 569
+    .quad 0x03FDC47E071233744
+    .quad 0x03FDC54539A6ABCD2  # 0.442646885679 570
+    .quad 0x03FDC54539A6ABCD2
+    .quad 0x03FDC5DAB908186FF  # 0.443217173690 571
+    .quad 0x03FDC5DAB908186FF
+    .quad 0x03FDC6704E4016FF7  # 0.443787787115 572
+    .quad 0x03FDC6704E4016FF7
+    .quad 0x03FDC737E1E38F4FB  # 0.444549111857 573
+    .quad 0x03FDC737E1E38F4FB
+    .quad 0x03FDC7CDAA290FEAD  # 0.445120486027 574
+    .quad 0x03FDC7CDAA290FEAD
+    .quad 0x03FDC863885A74D16  # 0.445692186852 575
+    .quad 0x03FDC863885A74D16
+    .quad 0x03FDC8F97C7E299DB  # 0.446264214707 576
+    .quad 0x03FDC8F97C7E299DB
+    .quad 0x03FDC9C18EDC7C26B  # 0.447027427871 577
+    .quad 0x03FDC9C18EDC7C26B
+    .quad 0x03FDCA57B64E9DB05  # 0.447600220249 578
+    .quad 0x03FDCA57B64E9DB05
+    .quad 0x03FDCAEDF3C88A364  # 0.448173340907 579
+    .quad 0x03FDCAEDF3C88A364
+    .quad 0x03FDCB844750B9995  # 0.448746790220 580
+    .quad 0x03FDCB844750B9995
+    .quad 0x03FDCC4CD90B3ECE5  # 0.449511901199 581
+    .quad 0x03FDCC4CD90B3ECE5
+    .quad 0x03FDCCE3602341C10  # 0.450086118843 582
+    .quad 0x03FDCCE3602341C10
+    .quad 0x03FDCD79FD5F2BC77  # 0.450660666403 583
+    .quad 0x03FDCD79FD5F2BC77
+    .quad 0x03FDCE10B0C581284  # 0.451235544257 584
+    .quad 0x03FDCE10B0C581284
+    .quad 0x03FDCED9C27EC6607  # 0.452002562511 585
+    .quad 0x03FDCED9C27EC6607
+    .quad 0x03FDCF70A9B6D3810  # 0.452578212532 586
+    .quad 0x03FDCF70A9B6D3810
+    .quad 0x03FDD007A72F19BBC  # 0.453154194116 587
+    .quad 0x03FDD007A72F19BBC
+    .quad 0x03FDD09EBAEE29DD8  # 0.453730507647 588
+    .quad 0x03FDD09EBAEE29DD8
+    .quad 0x03FDD1684D49F46AE  # 0.454499442710 589
+    .quad 0x03FDD1684D49F46AE
+    .quad 0x03FDD1FF951D1F1B3  # 0.455076532271 590
+    .quad 0x03FDD1FF951D1F1B3
+    .quad 0x03FDD296F34D0B65C  # 0.455653955057 591
+    .quad 0x03FDD296F34D0B65C
+    .quad 0x03FDD32E67E056BD5  # 0.456231711452 592
+    .quad 0x03FDD32E67E056BD5
+    .quad 0x03FDD3C5F2DDA1840  # 0.456809801843 593
+    .quad 0x03FDD3C5F2DDA1840
+    .quad 0x03FDD490246DEFA6A  # 0.457581109247 594
+    .quad 0x03FDD490246DEFA6A
+    .quad 0x03FDD527E3D1B95FC  # 0.458159980465 595
+    .quad 0x03FDD527E3D1B95FC
+    .quad 0x03FDD5BFB9B5AE71F  # 0.458739186968 596
+    .quad 0x03FDD5BFB9B5AE71F
+    .quad 0x03FDD657A6207C0DB  # 0.459318729146 597
+    .quad 0x03FDD657A6207C0DB
+    .quad 0x03FDD6EFA918D25CE  # 0.459898607388 598
+    .quad 0x03FDD6EFA918D25CE
+    .quad 0x03FDD7BA7AD9E7DA1  # 0.460672301817 599
+    .quad 0x03FDD7BA7AD9E7DA1
+    .quad 0x03FDD852B28BE5A0F  # 0.461252965726 600
+    .quad 0x03FDD852B28BE5A0F
+    .quad 0x03FDD8EB00E1CCE14  # 0.461833967001 601
+    .quad 0x03FDD8EB00E1CCE14
+    .quad 0x03FDD98365E25ABB9  # 0.462415306035 602
+    .quad 0x03FDD98365E25ABB9
+    .quad 0x03FDDA1BE1944F538  # 0.462996983220 603
+    .quad 0x03FDDA1BE1944F538
+    .quad 0x03FDDAE75484C9615  # 0.463773079495 604
+    .quad 0x03FDDAE75484C9615
+    .quad 0x03FDDB8005445488B  # 0.464355547233 605
+    .quad 0x03FDDB8005445488B
+    .quad 0x03FDDC18CCCBDCB83  # 0.464938354438 606
+    .quad 0x03FDDC18CCCBDCB83
+    .quad 0x03FDDCB1AB222F33D  # 0.465521501504 607
+    .quad 0x03FDDCB1AB222F33D
+    .quad 0x03FDDD4AA04E1C4B7  # 0.466104988830 608
+    .quad 0x03FDDD4AA04E1C4B7
+    .quad 0x03FDDDE3AC56775D2  # 0.466688816812 609
+    .quad 0x03FDDDE3AC56775D2
+    .quad 0x03FDDE7CCF4216D6E  # 0.467272985848 610
+    .quad 0x03FDDE7CCF4216D6E
+    .quad 0x03FDDF492177D7BBC  # 0.468052409114 611
+    .quad 0x03FDDF492177D7BBC
+    .quad 0x03FDDFE279E5BF4EE  # 0.468637375496 612
+    .quad 0x03FDDFE279E5BF4EE
+    .quad 0x03FDE07BE94DCC439  # 0.469222684263 613
+    .quad 0x03FDE07BE94DCC439
+    .quad 0x03FDE1156FB6E2626  # 0.469808335817 614
+    .quad 0x03FDE1156FB6E2626
+    .quad 0x03FDE1AF0D27E88D7  # 0.470394330560 615
+    .quad 0x03FDE1AF0D27E88D7
+    .quad 0x03FDE248C1A7C8C26  # 0.470980668894 616
+    .quad 0x03FDE248C1A7C8C26
+    .quad 0x03FDE2E28D3D701CC  # 0.471567351222 617
+    .quad 0x03FDE2E28D3D701CC
+    .quad 0x03FDE37C6FEFCED73  # 0.472154377948 618
+    .quad 0x03FDE37C6FEFCED73
+    .quad 0x03FDE449C232C39D8  # 0.472937616681 619
+    .quad 0x03FDE449C232C39D8
+    .quad 0x03FDE4E3DAEDDB5F6  # 0.473525448578 620
+    .quad 0x03FDE4E3DAEDDB5F6
+    .quad 0x03FDE57E0ADCE1EA5  # 0.474113626224 621
+    .quad 0x03FDE57E0ADCE1EA5
+    .quad 0x03FDE6185206D516F  # 0.474702150027 622
+    .quad 0x03FDE6185206D516F
+    .quad 0x03FDE6B2B072B5E6F  # 0.475291020395 623
+    .quad 0x03FDE6B2B072B5E6F
+    .quad 0x03FDE74D26278887A  # 0.475880237735 624
+    .quad 0x03FDE74D26278887A
+    .quad 0x03FDE7E7B32C5453F  # 0.476469802457 625
+    .quad 0x03FDE7E7B32C5453F
+    .quad 0x03FDE882578823D52  # 0.477059714970 626
+    .quad 0x03FDE882578823D52
+    .quad 0x03FDE91D134204C67  # 0.477649975686 627
+    .quad 0x03FDE91D134204C67
+    .quad 0x03FDE9B7E6610815A  # 0.478240585015 628
+    .quad 0x03FDE9B7E6610815A
+    .quad 0x03FDEA52D0EC41E5E  # 0.478831543369 629
+    .quad 0x03FDEA52D0EC41E5E
+    .quad 0x03FDEB218376ECFC0  # 0.479620031484 630
+    .quad 0x03FDEB218376ECFC0
+    .quad 0x03FDEBBCA4C4E9E87  # 0.480211805838 631
+    .quad 0x03FDEBBCA4C4E9E87
+    .quad 0x03FDEC57DD96CD0CB  # 0.480803930597 632
+    .quad 0x03FDEC57DD96CD0CB
+    .quad 0x03FDECF32DF3B887D  # 0.481396406174 633
+    .quad 0x03FDECF32DF3B887D
+    .quad 0x03FDED8E95E2D1B88  # 0.481989232987 634
+    .quad 0x03FDED8E95E2D1B88
+    .quad 0x03FDEE2A156B413E5  # 0.482582411453 635
+    .quad 0x03FDEE2A156B413E5
+    .quad 0x03FDEEC5AC9432FCB  # 0.483175941987 636
+    .quad 0x03FDEEC5AC9432FCB
+    .quad 0x03FDEF615B64D61C7  # 0.483769825010 637
+    .quad 0x03FDEF615B64D61C7
+    .quad 0x03FDEFFD21E45D0D1  # 0.484364060939 638
+    .quad 0x03FDEFFD21E45D0D1
+    .quad 0x03FDF0990019FD887  # 0.484958650194 639
+    .quad 0x03FDF0990019FD887
+    .quad 0x03FDF134F60CF092D  # 0.485553593197 640
+    .quad 0x03FDF134F60CF092D
+    .quad 0x03FDF1D103C4727E4  # 0.486148890367 641
+    .quad 0x03FDF1D103C4727E4
+    .quad 0x03FDF26D2947C2EC5  # 0.486744542127 642
+    .quad 0x03FDF26D2947C2EC5
+    .quad 0x03FDF309669E24CF9  # 0.487340548899 643
+    .quad 0x03FDF309669E24CF9
+    .quad 0x03FDF3A5BBCEDE6E1  # 0.487936911107 644
+    .quad 0x03FDF3A5BBCEDE6E1
+    .quad 0x03FDF44228E13963A  # 0.488533629176 645
+    .quad 0x03FDF44228E13963A
+    .quad 0x03FDF4DEADDC82A35  # 0.489130703529 646
+    .quad 0x03FDF4DEADDC82A35
+    .quad 0x03FDF57B4AC80A79A  # 0.489728134594 647
+    .quad 0x03FDF57B4AC80A79A
+    .quad 0x03FDF617FFAB248ED  # 0.490325922795 648
+    .quad 0x03FDF617FFAB248ED
+    .quad 0x03FDF6B4CC8D27E87  # 0.490924068561 649
+    .quad 0x03FDF6B4CC8D27E87
+    .quad 0x03FDF751B1756EEC8  # 0.491522572320 650
+    .quad 0x03FDF751B1756EEC8
+    .quad 0x03FDF7EEAE6B5761C  # 0.492121434499 651
+    .quad 0x03FDF7EEAE6B5761C
+    .quad 0x03FDF88BC3764273B  # 0.492720655530 652
+    .quad 0x03FDF88BC3764273B
+    .quad 0x03FDF928F09D94B32  # 0.493320235842 653
+    .quad 0x03FDF928F09D94B32
+    .quad 0x03FDF9C635E8B6192  # 0.493920175866 654
+    .quad 0x03FDF9C635E8B6192
+    .quad 0x03FDFA63935F1208C  # 0.494520476034 655
+    .quad 0x03FDFA63935F1208C
+    .quad 0x03FDFB0109081751A  # 0.495121136779 656
+    .quad 0x03FDFB0109081751A
+    .quad 0x03FDFB9E96EB38311  # 0.495722158534 657
+    .quad 0x03FDFB9E96EB38311
+    .quad 0x03FDFC3C3D0FEA555  # 0.496323541733 658
+    .quad 0x03FDFC3C3D0FEA555
+    .quad 0x03FDFCD9FB7DA6DEF  # 0.496925286812 659
+    .quad 0x03FDFCD9FB7DA6DEF
+    .quad 0x03FDFD77D23BEA634  # 0.497527394206 660
+    .quad 0x03FDFD77D23BEA634
+    .quad 0x03FDFE15C15234EE2  # 0.498129864352 661
+    .quad 0x03FDFE15C15234EE2
+    .quad 0x03FDFEB3C8C80A04E  # 0.498732697687 662
+    .quad 0x03FDFEB3C8C80A04E
+    .quad 0x03FDFF51E8A4F0A74  # 0.499335894649 663
+    .quad 0x03FDFF51E8A4F0A74
+    .quad 0x03FDFFF020F07352E  # 0.499939455677 664
+    .quad 0x03FDFFF020F07352E
+    .quad 0x03FE004738D910023  # 0.500543381211 665
+    .quad 0x03FE004738D910023
+    .quad 0x03FE00966D78C41CF  # 0.501147671692 666
+    .quad 0x03FE00966D78C41CF
+    .quad 0x03FE00E5AE5B207AB  # 0.501752327560 667
+    .quad 0x03FE00E5AE5B207AB
+    .quad 0x03FE011A8B18F0ED6  # 0.502155634684 668
+    .quad 0x03FE011A8B18F0ED6
+    .quad 0x03FE0169E072D7311  # 0.502760900515 669
+    .quad 0x03FE0169E072D7311
+    .quad 0x03FE01B942198A5A1  # 0.503366532915 670
+    .quad 0x03FE01B942198A5A1
+    .quad 0x03FE0208B010DB642  # 0.503972532327 671
+    .quad 0x03FE0208B010DB642
+    .quad 0x03FE02582A5C9D122  # 0.504578899198 672
+    .quad 0x03FE02582A5C9D122
+    .quad 0x03FE02A7B100A3EF0  # 0.505185633972 673
+    .quad 0x03FE02A7B100A3EF0
+    .quad 0x03FE02F74400C64EA  # 0.505792737097 674
+    .quad 0x03FE02F74400C64EA
+    .quad 0x03FE0346E360DC4F9  # 0.506400209020 675
+    .quad 0x03FE0346E360DC4F9
+    .quad 0x03FE03968F24BFDB6  # 0.507008050190 676
+    .quad 0x03FE03968F24BFDB6
+    .quad 0x03FE03E647504CA89  # 0.507616261055 677
+    .quad 0x03FE03E647504CA89
+    .quad 0x03FE04360BE7603AE  # 0.508224842066 678
+    .quad 0x03FE04360BE7603AE
+    .quad 0x03FE046B4089BE0FD  # 0.508630768599 679
+    .quad 0x03FE046B4089BE0FD
+    .quad 0x03FE04BB19DCA36B3  # 0.509239967521 680
+    .quad 0x03FE04BB19DCA36B3
+    .quad 0x03FE050AFFA5671A5  # 0.509849537793 681
+    .quad 0x03FE050AFFA5671A5
+    .quad 0x03FE055AF1E7ED47B  # 0.510459479867 682
+    .quad 0x03FE055AF1E7ED47B
+    .quad 0x03FE05AAF0A81BF04  # 0.511069794198 683
+    .quad 0x03FE05AAF0A81BF04
+    .quad 0x03FE05FAFBE9DAE58  # 0.511680481240 684
+    .quad 0x03FE05FAFBE9DAE58
+    .quad 0x03FE064B13B113CDD  # 0.512291541448 685
+    .quad 0x03FE064B13B113CDD
+    .quad 0x03FE069B3801B2263  # 0.512902975280 686
+    .quad 0x03FE069B3801B2263
+    .quad 0x03FE06D0AC85B63A2  # 0.513310805628 687
+    .quad 0x03FE06D0AC85B63A2
+    .quad 0x03FE0720E5C40DF1D  # 0.513922863181 688
+    .quad 0x03FE0720E5C40DF1D
+    .quad 0x03FE07712B9648153  # 0.514535295577 689
+    .quad 0x03FE07712B9648153
+    .quad 0x03FE07C17E0056E7C  # 0.515148103277 690
+    .quad 0x03FE07C17E0056E7C
+    .quad 0x03FE0811DD062E889  # 0.515761286740 691
+    .quad 0x03FE0811DD062E889
+    .quad 0x03FE086248ABC4F3B  # 0.516374846428 692
+    .quad 0x03FE086248ABC4F3B
+    .quad 0x03FE08B2C0F512033  # 0.516988782802 693
+    .quad 0x03FE08B2C0F512033
+    .quad 0x03FE08E86D82DA3EE  # 0.517398283218 694
+    .quad 0x03FE08E86D82DA3EE
+    .quad 0x03FE0938FAE5D8E9B  # 0.518012848432 695
+    .quad 0x03FE0938FAE5D8E9B
+    .quad 0x03FE098994F72C539  # 0.518627791569 696
+    .quad 0x03FE098994F72C539
+    .quad 0x03FE09DA3BBAD339C  # 0.519243113094 697
+    .quad 0x03FE09DA3BBAD339C
+    .quad 0x03FE0A2AEF34CE3D1  # 0.519858813473 698
+    .quad 0x03FE0A2AEF34CE3D1
+    .quad 0x03FE0A7BAF691FE34  # 0.520474893172 699
+    .quad 0x03FE0A7BAF691FE34
+    .quad 0x03FE0AB18BF5823C3  # 0.520885823936 700
+    .quad 0x03FE0AB18BF5823C3
+    .quad 0x03FE0B02616952989  # 0.521502536876 701
+    .quad 0x03FE0B02616952989
+    .quad 0x03FE0B5343A234476  # 0.522119630385 702
+    .quad 0x03FE0B5343A234476
+    .quad 0x03FE0BA432A430CA2  # 0.522737104934 703
+    .quad 0x03FE0BA432A430CA2
+    .quad 0x03FE0BF52E73538CE  # 0.523354960993 704
+    .quad 0x03FE0BF52E73538CE
+    .quad 0x03FE0C463713A9E6F  # 0.523973199034 705
+    .quad 0x03FE0C463713A9E6F
+    .quad 0x03FE0C7C43F4C861E  # 0.524385570174 706
+    .quad 0x03FE0C7C43F4C861E
+    .quad 0x03FE0CCD61FAD07D2  # 0.525004445903 707
+    .quad 0x03FE0CCD61FAD07D2
+    .quad 0x03FE0D1E8CDCE3DB6  # 0.525623704876 708
+    .quad 0x03FE0D1E8CDCE3DB6
+    .quad 0x03FE0D6FC49F16E93  # 0.526243347569 709
+    .quad 0x03FE0D6FC49F16E93
+    .quad 0x03FE0DC109458004A  # 0.526863374456 710
+    .quad 0x03FE0DC109458004A
+    .quad 0x03FE0DF73E353F0ED  # 0.527276939392 711
+    .quad 0x03FE0DF73E353F0ED
+    .quad 0x03FE0E4898611CCE1  # 0.527897607665 712
+    .quad 0x03FE0E4898611CCE1
+    .quad 0x03FE0E99FF7C20738  # 0.528518661406 713
+    .quad 0x03FE0E99FF7C20738
+    .quad 0x03FE0EEB738A67874  # 0.529140101094 714
+    .quad 0x03FE0EEB738A67874
+    .quad 0x03FE0F21C81D1ADC3  # 0.529554608872 715
+    .quad 0x03FE0F21C81D1ADC3
+    .quad 0x03FE0F7351C9FCD7F  # 0.530176692874 716
+    .quad 0x03FE0F7351C9FCD7F
+    .quad 0x03FE0FC4E875254C1  # 0.530799164104 717
+    .quad 0x03FE0FC4E875254C1
+    .quad 0x03FE10168C22B8FB9  # 0.531422023047 718
+    .quad 0x03FE10168C22B8FB9
+    .quad 0x03FE10683CD6DEA54  # 0.532045270185 719
+    .quad 0x03FE10683CD6DEA54
+    .quad 0x03FE109EB9E2E4C97  # 0.532460984179 720
+    .quad 0x03FE109EB9E2E4C97
+    .quad 0x03FE10F08055E7785  # 0.533084879385 721
+    .quad 0x03FE10F08055E7785
+    .quad 0x03FE114253DA97DA0  # 0.533709164079 722
+    .quad 0x03FE114253DA97DA0
+    .quad 0x03FE1194347523FDC  # 0.534333838748 723
+    .quad 0x03FE1194347523FDC
+    .quad 0x03FE11CAD1789B0F8  # 0.534750505421 724
+    .quad 0x03FE11CAD1789B0F8
+    .quad 0x03FE121CC7EB8F7E6  # 0.535375831132 725
+    .quad 0x03FE121CC7EB8F7E6
+    .quad 0x03FE126ECB7F8F007  # 0.536001548120 726
+    .quad 0x03FE126ECB7F8F007
+    .quad 0x03FE12A57FDA37091  # 0.536418910396 727
+    .quad 0x03FE12A57FDA37091
+    .quad 0x03FE12F799594EFBC  # 0.537045280601 728
+    .quad 0x03FE12F799594EFBC
+    .quad 0x03FE1349C004AFB00  # 0.537672043392 729
+    .quad 0x03FE1349C004AFB00
+    .quad 0x03FE139BF3E094003  # 0.538299199261 730
+    .quad 0x03FE139BF3E094003
+    .quad 0x03FE13D2C873C5E13  # 0.538717521794 731
+    .quad 0x03FE13D2C873C5E13
+    .quad 0x03FE142512549C16C  # 0.539345333889 732
+    .quad 0x03FE142512549C16C
+    .quad 0x03FE14776971477F1  # 0.539973540381 733
+    .quad 0x03FE14776971477F1
+    .quad 0x03FE14C9CDCE0A74D  # 0.540602141763 734
+    .quad 0x03FE14C9CDCE0A74D
+    .quad 0x03FE1500C2BFD1561  # 0.541021428981 735
+    .quad 0x03FE1500C2BFD1561
+    .quad 0x03FE15533D3B8D7B3  # 0.541650689621 736
+    .quad 0x03FE15533D3B8D7B3
+    .quad 0x03FE15A5C502C6DC5  # 0.542280346478 737
+    .quad 0x03FE15A5C502C6DC5
+    .quad 0x03FE15DCD1973457B  # 0.542700338085 738
+    .quad 0x03FE15DCD1973457B
+    .quad 0x03FE162F6F9071F76  # 0.543330656416 739
+    .quad 0x03FE162F6F9071F76
+    .quad 0x03FE16821AE0A13C6  # 0.543961372300 740
+    .quad 0x03FE16821AE0A13C6
+    .quad 0x03FE16B93F2C12808  # 0.544382070665 741
+    .quad 0x03FE16B93F2C12808
+    .quad 0x03FE170C00C169B51  # 0.545013450251 742
+    .quad 0x03FE170C00C169B51
+    .quad 0x03FE175ECFB935CC6  # 0.545645228728 743
+    .quad 0x03FE175ECFB935CC6
+    .quad 0x03FE17B1AC17CBD5B  # 0.546277406602 744
+    .quad 0x03FE17B1AC17CBD5B
+    .quad 0x03FE17E8F12052E8A  # 0.546699080654 745
+    .quad 0x03FE17E8F12052E8A
+    .quad 0x03FE183BE3DE8A7AF  # 0.547331925312 746
+    .quad 0x03FE183BE3DE8A7AF
+    .quad 0x03FE188EE40F23CA7  # 0.547965170715 747
+    .quad 0x03FE188EE40F23CA7
+    .quad 0x03FE18C640FF75F06  # 0.548387557205 748
+    .quad 0x03FE18C640FF75F06
+    .quad 0x03FE191957A30FA51  # 0.549021471648 749
+    .quad 0x03FE191957A30FA51
+    .quad 0x03FE196C7BC4B1F3A  # 0.549655788193 750
+    .quad 0x03FE196C7BC4B1F3A
+    .quad 0x03FE19A3F0B1860BD  # 0.550078889532 751
+    .quad 0x03FE19A3F0B1860BD
+    .quad 0x03FE19F72B59A0CEC  # 0.550713877383 752
+    .quad 0x03FE19F72B59A0CEC
+    .quad 0x03FE1A4A738B7A33C  # 0.551349268700 753
+    .quad 0x03FE1A4A738B7A33C
+    .quad 0x03FE1A820089A2156  # 0.551773087312 754
+    .quad 0x03FE1A820089A2156
+    .quad 0x03FE1AD55F55855C8  # 0.552409152212 755
+    .quad 0x03FE1AD55F55855C8
+    .quad 0x03FE1B28CBB6EC93E  # 0.553045621948 756
+    .quad 0x03FE1B28CBB6EC93E
+    .quad 0x03FE1B6070DB553D8  # 0.553470160269 757
+    .quad 0x03FE1B6070DB553D8
+    .quad 0x03FE1BB3F3EA714F6  # 0.554107305878 758
+    .quad 0x03FE1BB3F3EA714F6
+    .quad 0x03FE1BEBA8316EF2C  # 0.554532295260 759
+    .quad 0x03FE1BEBA8316EF2C
+    .quad 0x03FE1C3F41FA97C6B  # 0.555170118179 760
+    .quad 0x03FE1C3F41FA97C6B
+    .quad 0x03FE1C92E96C86020  # 0.555808348176 761
+    .quad 0x03FE1C92E96C86020
+    .quad 0x03FE1CCAB5FBFFEE1  # 0.556234061252 762
+    .quad 0x03FE1CCAB5FBFFEE1
+    .quad 0x03FE1D1E743BCFC47  # 0.556872970868 763
+    .quad 0x03FE1D1E743BCFC47
+    .quad 0x03FE1D72403052E75  # 0.557512288951 764
+    .quad 0x03FE1D72403052E75
+    .quad 0x03FE1DAA251D7E433  # 0.557938728190 765
+    .quad 0x03FE1DAA251D7E433
+    .quad 0x03FE1DFE07F3D1DAB  # 0.558578728212 766
+    .quad 0x03FE1DFE07F3D1DAB
+    .quad 0x03FE1E35FC265D75E  # 0.559005622562 767
+    .quad 0x03FE1E35FC265D75E
+    .quad 0x03FE1E89F5EB04126  # 0.559646305979 768
+    .quad 0x03FE1E89F5EB04126
+    .quad 0x03FE1EDDFD77E1FEF  # 0.560287400135 769
+    .quad 0x03FE1EDDFD77E1FEF
+    .quad 0x03FE1F160A2AD0DA3  # 0.560715024687 770
+    .quad 0x03FE1F160A2AD0DA3
+    .quad 0x03FE1F6A28BA1B476  # 0.561356804579 771
+    .quad 0x03FE1F6A28BA1B476
+    .quad 0x03FE1FBE551DB43C1  # 0.561998996616 772
+    .quad 0x03FE1FBE551DB43C1
+    .quad 0x03FE1FF67A6684F47  # 0.562427353873 773
+    .quad 0x03FE1FF67A6684F47
+    .quad 0x03FE204ABDE0BE5DF  # 0.563070233998 774
+    .quad 0x03FE204ABDE0BE5DF
+    .quad 0x03FE2082F29233211  # 0.563499050471 775
+    .quad 0x03FE2082F29233211
+    .quad 0x03FE20D74D2FBAFE4  # 0.564142620160 776
+    .quad 0x03FE20D74D2FBAFE4
+    .quad 0x03FE210F91524B469  # 0.564571896835 777
+    .quad 0x03FE210F91524B469
+    .quad 0x03FE2164031FDA0B0  # 0.565216157568 778
+    .quad 0x03FE2164031FDA0B0
+    .quad 0x03FE21B882DD26040  # 0.565860833641 779
+    .quad 0x03FE21B882DD26040
+    .quad 0x03FE21F0DFC65CEEC  # 0.566290848698 780
+    .quad 0x03FE21F0DFC65CEEC
+    .quad 0x03FE224576C81FFE0  # 0.566936218194 781
+    .quad 0x03FE224576C81FFE0
+    .quad 0x03FE227DE33896A44  # 0.567366696031 782
+    .quad 0x03FE227DE33896A44
+    .quad 0x03FE22D2918BA4A31  # 0.568012760445 783
+    .quad 0x03FE22D2918BA4A31
+    .quad 0x03FE23274DE272A83  # 0.568659242528 784
+    .quad 0x03FE23274DE272A83
+    .quad 0x03FE235FD33D232FC  # 0.569090462888 785
+    .quad 0x03FE235FD33D232FC
+    .quad 0x03FE23B4A6F9D8688  # 0.569737642287 786
+    .quad 0x03FE23B4A6F9D8688
+    .quad 0x03FE23ED3BF21CA33  # 0.570169328026 787
+    .quad 0x03FE23ED3BF21CA33
+    .quad 0x03FE24422721A89D7  # 0.570817206248 788
+    .quad 0x03FE24422721A89D7
+    .quad 0x03FE247ACBC023D2B  # 0.571249358372 789
+    .quad 0x03FE247ACBC023D2B
+    .quad 0x03FE24CFCE6F80D9B  # 0.571897936927 790
+    .quad 0x03FE24CFCE6F80D9B
+    .quad 0x03FE250882BCDD7D8  # 0.572330556445 791
+    .quad 0x03FE250882BCDD7D8
+    .quad 0x03FE255D9CF910A56  # 0.572979836849 792
+    .quad 0x03FE255D9CF910A56
+    .quad 0x03FE25B2C55CD5762  # 0.573629539091 793
+    .quad 0x03FE25B2C55CD5762
+    .quad 0x03FE25EB92D41992D  # 0.574062908546 794
+    .quad 0x03FE25EB92D41992D
+    .quad 0x03FE2640D2D99FFEA  # 0.574713315073 795
+    .quad 0x03FE2640D2D99FFEA
+    .quad 0x03FE2679B0166F51C  # 0.575147154559 796
+    .quad 0x03FE2679B0166F51C
+    .quad 0x03FE26CF07CAD8B00  # 0.575798266899 797
+    .quad 0x03FE26CF07CAD8B00
+    .quad 0x03FE2707F4D5F7C40  # 0.576232577438 798
+    .quad 0x03FE2707F4D5F7C40
+    .quad 0x03FE275D644670606  # 0.576884397124 799
+    .quad 0x03FE275D644670606
+    .quad 0x03FE27966128AB11B  # 0.577319179739 800
+    .quad 0x03FE27966128AB11B
+    .quad 0x03FE27EBE8626A387  # 0.577971708311 801
+    .quad 0x03FE27EBE8626A387
+    .quad 0x03FE2824F52493BD2  # 0.578406964030 802
+    .quad 0x03FE2824F52493BD2
+    .quad 0x03FE287A9434DBC7B  # 0.579060203030 803
+    .quad 0x03FE287A9434DBC7B
+    .quad 0x03FE28B3B0DFCEB80  # 0.579495932884 804
+    .quad 0x03FE28B3B0DFCEB80
+    .quad 0x03FE290967D3ED18D  # 0.580149883861 805
+    .quad 0x03FE290967D3ED18D
+    .quad 0x03FE294294708B773  # 0.580586088885 806
+    .quad 0x03FE294294708B773
+    .quad 0x03FE29986355D8C69  # 0.581240753393 807
+    .quad 0x03FE29986355D8C69
+    .quad 0x03FE29D19FED0C082  # 0.581677434622 808
+    .quad 0x03FE29D19FED0C082
+    .quad 0x03FE2A2786D0EC107  # 0.582332814220 809
+    .quad 0x03FE2A2786D0EC107
+    .quad 0x03FE2A60D36BA5253  # 0.582769972697 810
+    .quad 0x03FE2A60D36BA5253
+    .quad 0x03FE2AB6D25B86EF7  # 0.583426068948 811
+    .quad 0x03FE2AB6D25B86EF7
+    .quad 0x03FE2AF02F02BE4AB  # 0.583863705716 812
+    .quad 0x03FE2AF02F02BE4AB
+    .quad 0x03FE2B46460C1C2B3  # 0.584520520190 813
+    .quad 0x03FE2B46460C1C2B3
+    .quad 0x03FE2B7FB2C8D1CC1  # 0.584958636297 814
+    .quad 0x03FE2B7FB2C8D1CC1
+    .quad 0x03FE2BD5E1F9316F2  # 0.585616170568 815
+    .quad 0x03FE2BD5E1F9316F2
+    .quad 0x03FE2C0F5ED46CE8D  # 0.586054767066 816
+    .quad 0x03FE2C0F5ED46CE8D
+    .quad 0x03FE2C65A6395F5F5  # 0.586713022712 817
+    .quad 0x03FE2C65A6395F5F5
+    .quad 0x03FE2C9F333C2FE1E  # 0.587152100656 818
+    .quad 0x03FE2C9F333C2FE1E
+    .quad 0x03FE2CF592E351AE5  # 0.587811079263 819
+    .quad 0x03FE2CF592E351AE5
+    .quad 0x03FE2D2F3016CE0EF  # 0.588250639709 820
+    .quad 0x03FE2D2F3016CE0EF
+    .quad 0x03FE2D85A80DC7324  # 0.588910342867 821
+    .quad 0x03FE2D85A80DC7324
+    .quad 0x03FE2DBF557B0DF43  # 0.589350386878 822
+    .quad 0x03FE2DBF557B0DF43
+    .quad 0x03FE2E15E5CF91FA7  # 0.590010816181 823
+    .quad 0x03FE2E15E5CF91FA7
+    .quad 0x03FE2E4FA37FC9577  # 0.590451344823 824
+    .quad 0x03FE2E4FA37FC9577
+    .quad 0x03FE2E8967B3BF4E1  # 0.590892067615 825
+    .quad 0x03FE2E8967B3BF4E1
+    .quad 0x03FE2EE01A3BED567  # 0.591553516212 826
+    .quad 0x03FE2EE01A3BED567
+    .quad 0x03FE2F19EEBFB00BA  # 0.591994725131 827
+    .quad 0x03FE2F19EEBFB00BA
+    .quad 0x03FE2F70B9C67A7C2  # 0.592656903723 828
+    .quad 0x03FE2F70B9C67A7C2
+    .quad 0x03FE2FAA9EA342D04  # 0.593098599843 829
+    .quad 0x03FE2FAA9EA342D04
+    .quad 0x03FE3001823684D73  # 0.593761510043 830
+    .quad 0x03FE3001823684D73
+    .quad 0x03FE303B7775937EF  # 0.594203694441 831
+    .quad 0x03FE303B7775937EF
+    .quad 0x03FE309273A3340FC  # 0.594867337868 832
+    .quad 0x03FE309273A3340FC
+    .quad 0x03FE30CC794DD19D0  # 0.595310011625 833
+    .quad 0x03FE30CC794DD19D0
+    .quad 0x03FE3106858C76BB7  # 0.595752881428 834
+    .quad 0x03FE3106858C76BB7
+    .quad 0x03FE315DA4434068B  # 0.596417554101 835
+    .quad 0x03FE315DA4434068B
+    .quad 0x03FE3197C0FA80E6A  # 0.596860914783 836
+    .quad 0x03FE3197C0FA80E6A
+    .quad 0x03FE31EEF86D36EF1  # 0.597526324589 837
+    .quad 0x03FE31EEF86D36EF1
+    .quad 0x03FE322925A66E62D  # 0.597970177237 838
+    .quad 0x03FE322925A66E62D
+    .quad 0x03FE328075E32022F  # 0.598636325813 839
+    .quad 0x03FE328075E32022F
+    .quad 0x03FE32BAB3A7B21E9  # 0.599080671521 840
+    .quad 0x03FE32BAB3A7B21E9
+    .quad 0x03FE32F4F80D0B1BD  # 0.599525214760 841
+    .quad 0x03FE32F4F80D0B1BD
+    .quad 0x03FE334C6B15D30DD  # 0.600192400374 842
+    .quad 0x03FE334C6B15D30DD
+    .quad 0x03FE3386C013B90D6  # 0.600637438209 843
+    .quad 0x03FE3386C013B90D6
+    .quad 0x03FE33DE4C086C40A  # 0.601305366543 844
+    .quad 0x03FE33DE4C086C40A
+    .quad 0x03FE3418B1A85622C  # 0.601750900077 845
+    .quad 0x03FE3418B1A85622C
+    .quad 0x03FE34531DF21CFE3  # 0.602196632199 846
+    .quad 0x03FE34531DF21CFE3
+    .quad 0x03FE34AACCE299BA5  # 0.602865603124 847
+    .quad 0x03FE34AACCE299BA5
+    .quad 0x03FE34E549DBB21EF  # 0.603311832493 848
+    .quad 0x03FE34E549DBB21EF
+    .quad 0x03FE353D11DA4F855  # 0.603981550121 849
+    .quad 0x03FE353D11DA4F855
+    .quad 0x03FE35779F8C43D6D  # 0.604428277847 850
+    .quad 0x03FE35779F8C43D6D
+    .quad 0x03FE35B233F13DD4A  # 0.604875205229 851
+    .quad 0x03FE35B233F13DD4A
+    .quad 0x03FE360A1F1BBA738  # 0.605545971045 852
+    .quad 0x03FE360A1F1BBA738
+    .quad 0x03FE3644C446F97BC  # 0.605993398346 853
+    .quad 0x03FE3644C446F97BC
+    .quad 0x03FE367F702A9EA94  # 0.606441025927 854
+    .quad 0x03FE367F702A9EA94
+    .quad 0x03FE36D77E9D34FD7  # 0.607112843218 855
+    .quad 0x03FE36D77E9D34FD7
+    .quad 0x03FE37123B54987B7  # 0.607560972287 856
+    .quad 0x03FE37123B54987B7
+    .quad 0x03FE376A630C0A1D6  # 0.608233542652 857
+    .quad 0x03FE376A630C0A1D6
+    .quad 0x03FE37A530A0D5A31  # 0.608682174333 858
+    .quad 0x03FE37A530A0D5A31
+    .quad 0x03FE37E004F74E13B  # 0.609131007374 859
+    .quad 0x03FE37E004F74E13B
+    .quad 0x03FE383850278CFD9  # 0.609804634884 860
+    .quad 0x03FE383850278CFD9
+    .quad 0x03FE3873356902AB7  # 0.610253972119 861
+    .quad 0x03FE3873356902AB7
+    .quad 0x03FE38AE2171976E8  # 0.610703511349 862
+    .quad 0x03FE38AE2171976E8
+    .quad 0x03FE390690373AFFF  # 0.611378199331 863
+    .quad 0x03FE390690373AFFF
+    .quad 0x03FE39418D3872A53  # 0.611828244343 864
+    .quad 0x03FE39418D3872A53
+    .quad 0x03FE397C91064221F  # 0.612278491987 865
+    .quad 0x03FE397C91064221F
+    .quad 0x03FE39D5237E045A5  # 0.612954243787 866
+    .quad 0x03FE39D5237E045A5
+    .quad 0x03FE3A1038522CE82  # 0.613404998809 867
+    .quad 0x03FE3A1038522CE82
+    .quad 0x03FE3A68E45AD354B  # 0.614081512534 868
+    .quad 0x03FE3A68E45AD354B
+    .quad 0x03FE3AA40A3F2A68B  # 0.614532776080 869
+    .quad 0x03FE3AA40A3F2A68B
+    .quad 0x03FE3ADF36F98A182  # 0.614984243356 870
+    .quad 0x03FE3ADF36F98A182
+    .quad 0x03FE3B3806E5DF340  # 0.615661826668 871
+    .quad 0x03FE3B3806E5DF340
+    .quad 0x03FE3B7344BE40311  # 0.616113804077 872
+    .quad 0x03FE3B7344BE40311
+    .quad 0x03FE3BAE897234A87  # 0.616565985862 873
+    .quad 0x03FE3BAE897234A87
+    .quad 0x03FE3C077D5F51881  # 0.617244642149 874
+    .quad 0x03FE3C077D5F51881
+    .quad 0x03FE3C42D33F2AE7B  # 0.617697335683 875
+    .quad 0x03FE3C42D33F2AE7B
+    .quad 0x03FE3C7E30002960C  # 0.618150234241 876
+    .quad 0x03FE3C7E30002960C
+    .quad 0x03FE3CD7480B4A8A3  # 0.618829966906 877
+    .quad 0x03FE3CD7480B4A8A3
+    .quad 0x03FE3D12B60622748  # 0.619283378838 878
+    .quad 0x03FE3D12B60622748
+    .quad 0x03FE3D4E2AE7B7E2B  # 0.619736996447 879
+    .quad 0x03FE3D4E2AE7B7E2B
+    .quad 0x03FE3D89A6B1A558D  # 0.620190819917 880
+    .quad 0x03FE3D89A6B1A558D
+    .quad 0x03FE3DE2ED57B1F9B  # 0.620871941524 881
+    .quad 0x03FE3DE2ED57B1F9B
+    .quad 0x03FE3E1E7A6D8330E  # 0.621326280468 882
+    .quad 0x03FE3E1E7A6D8330E
+    .quad 0x03FE3E5A0E714DA6E  # 0.621780825931 883
+    .quad 0x03FE3E5A0E714DA6E
+    .quad 0x03FE3EB37978B85B6  # 0.622463031756 884
+    .quad 0x03FE3EB37978B85B6
+    .quad 0x03FE3EEF1ED68236B  # 0.622918094335 885
+    .quad 0x03FE3EEF1ED68236B
+    .quad 0x03FE3F2ACB27ED6C7  # 0.623373364090 886
+    .quad 0x03FE3F2ACB27ED6C7
+    .quad 0x03FE3F845AAE68C81  # 0.624056657591 887
+    .quad 0x03FE3F845AAE68C81
+    .quad 0x03FE3FC0186800514  # 0.624512446113 888
+    .quad 0x03FE3FC0186800514
+    .quad 0x03FE3FFBDD1AE8406  # 0.624968442473 889
+    .quad 0x03FE3FFBDD1AE8406
+    .quad 0x03FE4037A8C8C197A  # 0.625424646860 890
+    .quad 0x03FE4037A8C8C197A
+    .quad 0x03FE409167679DD99  # 0.626109343909 891
+    .quad 0x03FE409167679DD99
+    .quad 0x03FE40CD448FF6DD6  # 0.626566069196 892
+    .quad 0x03FE40CD448FF6DD6
+    .quad 0x03FE410928B8F950F  # 0.627023003177 893
+    .quad 0x03FE410928B8F950F
+    .quad 0x03FE41630C1B50AFF  # 0.627708795866 894
+    .quad 0x03FE41630C1B50AFF
+    .quad 0x03FE419F01CD27AD0  # 0.628166252416 895
+    .quad 0x03FE419F01CD27AD0
+    .quad 0x03FE41DAFE85672B9  # 0.628623918328 896
+    .quad 0x03FE41DAFE85672B9
+    .quad 0x03FE42170245B4C6A  # 0.629081793794 897
+    .quad 0x03FE42170245B4C6A
+    .quad 0x03FE42711518DF546  # 0.629769000326 898
+    .quad 0x03FE42711518DF546
+    .quad 0x03FE42AD2A74888A0  # 0.630227400518 899
+    .quad 0x03FE42AD2A74888A0
+    .quad 0x03FE42E946DE080C0  # 0.630686010936 900
+    .quad 0x03FE42E946DE080C0
+    .quad 0x03FE43437EB9D9424  # 0.631374321162 901
+    .quad 0x03FE43437EB9D9424
+    .quad 0x03FE437FACCD31C10  # 0.631833457993 902
+    .quad 0x03FE437FACCD31C10
+    .quad 0x03FE43BBE1F42FE09  # 0.632292805727 903
+    .quad 0x03FE43BBE1F42FE09
+    .quad 0x03FE43F81E307DE5E  # 0.632752364559 904
+    .quad 0x03FE43F81E307DE5E
+    .quad 0x03FE445285D68EA69  # 0.633442099038 905
+    .quad 0x03FE445285D68EA69
+    .quad 0x03FE448ED3CF71355  # 0.633902186463 906
+    .quad 0x03FE448ED3CF71355
+    .quad 0x03FE44CB28E37C3EE  # 0.634362485666 907
+    .quad 0x03FE44CB28E37C3EE
+    .quad 0x03FE450785145CAFE  # 0.634822996841 908
+    .quad 0x03FE450785145CAFE
+    .quad 0x03FE45621CB769366  # 0.635514161481 909
+    .quad 0x03FE45621CB769366
+    .quad 0x03FE459E8AB7B799D  # 0.635975203444 910
+    .quad 0x03FE459E8AB7B799D
+    .quad 0x03FE45DAFFDABD4DB  # 0.636436458065 911
+    .quad 0x03FE45DAFFDABD4DB
+    .quad 0x03FE46177C2229EC0  # 0.636897925539 912
+    .quad 0x03FE46177C2229EC0
+    .quad 0x03FE467243F53F69E  # 0.637590526283 913
+    .quad 0x03FE467243F53F69E
+    .quad 0x03FE46AED21F117FC  # 0.638052526753 914
+    .quad 0x03FE46AED21F117FC
+    .quad 0x03FE46EB677335D13  # 0.638514740766 915
+    .quad 0x03FE46EB677335D13
+    .quad 0x03FE472803F35EAAE  # 0.638977168520 916
+    .quad 0x03FE472803F35EAAE
+    .quad 0x03FE4764A7A13EF3B  # 0.639439810212 917
+    .quad 0x03FE4764A7A13EF3B
+    .quad 0x03FE47BFAA9F80271  # 0.640134174319 918
+    .quad 0x03FE47BFAA9F80271
+    .quad 0x03FE47FC60471DAF8  # 0.640597351724 919
+    .quad 0x03FE47FC60471DAF8
+    .quad 0x03FE48391D226992D  # 0.641060743762 920
+    .quad 0x03FE48391D226992D
+    .quad 0x03FE4875E1331971E  # 0.641524350631 921
+    .quad 0x03FE4875E1331971E
+    .quad 0x03FE48D114D3FB884  # 0.642220164181 922
+    .quad 0x03FE48D114D3FB884
+    .quad 0x03FE490DEAF1A3FC8  # 0.642684309003 923
+    .quad 0x03FE490DEAF1A3FC8
+    .quad 0x03FE494AC84AB0ED3  # 0.643148669355 924
+    .quad 0x03FE494AC84AB0ED3
+    .quad 0x03FE4987ACE0DABB0  # 0.643613245438 925
+    .quad 0x03FE4987ACE0DABB0
+    .quad 0x03FE49C498B5DA63F  # 0.644078037452 926
+    .quad 0x03FE49C498B5DA63F
+    .quad 0x03FE4A20080EF10B2  # 0.644775630783 927
+    .quad 0x03FE4A20080EF10B2
+    .quad 0x03FE4A5D060894B8C  # 0.645240963504 928
+    .quad 0x03FE4A5D060894B8C
+    .quad 0x03FE4A9A0B471A943  # 0.645706512861 929
+    .quad 0x03FE4A9A0B471A943
+    .quad 0x03FE4AD717CC3E626  # 0.646172279055 930
+    .quad 0x03FE4AD717CC3E626
+    .quad 0x03FE4B142B99BC871  # 0.646638262288 931
+    .quad 0x03FE4B142B99BC871
+    .quad 0x03FE4B6FD6F970C1F  # 0.647337644529 932
+    .quad 0x03FE4B6FD6F970C1F
+    .quad 0x03FE4BACFD036D080  # 0.647804171246 933
+    .quad 0x03FE4BACFD036D080
+    .quad 0x03FE4BEA2A5BDBE87  # 0.648270915712 934
+    .quad 0x03FE4BEA2A5BDBE87
+    .quad 0x03FE4C275F047C956  # 0.648737878130 935
+    .quad 0x03FE4C275F047C956
+    .quad 0x03FE4C649AFF0EE16  # 0.649205058703 936
+    .quad 0x03FE4C649AFF0EE16
+    .quad 0x03FE4CC082B46485A  # 0.649906239052 937
+    .quad 0x03FE4CC082B46485A
+    .quad 0x03FE4CFDD1037E37C  # 0.650373965908 938
+    .quad 0x03FE4CFDD1037E37C
+    .quad 0x03FE4D3B26AAADDD9  # 0.650841911635 939
+    .quad 0x03FE4D3B26AAADDD9
+    .quad 0x03FE4D7883ABB61F6  # 0.651310076438 940
+    .quad 0x03FE4D7883ABB61F6
+    .quad 0x03FE4DB5E8085A477  # 0.651778460521 941
+    .quad 0x03FE4DB5E8085A477
+    .quad 0x03FE4DF353C25E42B  # 0.652247064091 942
+    .quad 0x03FE4DF353C25E42B
+    .quad 0x03FE4E4F832C560DD  # 0.652950381434 943
+    .quad 0x03FE4E4F832C560DD
+    .quad 0x03FE4E8D015786F16  # 0.653419534621 944
+    .quad 0x03FE4E8D015786F16
+    .quad 0x03FE4ECA86E64A683  # 0.653888908016 945
+    .quad 0x03FE4ECA86E64A683
+    .quad 0x03FE4F0813DA673DD  # 0.654358501826 946
+    .quad 0x03FE4F0813DA673DD
+    .quad 0x03FE4F45A835A4E19  # 0.654828316258 947
+    .quad 0x03FE4F45A835A4E19
+    .quad 0x03FE4F8343F9CB678  # 0.655298351519 948
+    .quad 0x03FE4F8343F9CB678
+    .quad 0x03FE4FDFBB88A119A  # 0.656003818920 949
+    .quad 0x03FE4FDFBB88A119A
+    .quad 0x03FE501D69DADD660  # 0.656474407164 950
+    .quad 0x03FE501D69DADD660
+    .quad 0x03FE505B1F9C43ED7  # 0.656945216966 951
+    .quad 0x03FE505B1F9C43ED7
+    .quad 0x03FE5098DCCE9FABA  # 0.657416248534 952
+    .quad 0x03FE5098DCCE9FABA
+    .quad 0x03FE50D6A173BC425  # 0.657887502077 953
+    .quad 0x03FE50D6A173BC425
+    .quad 0x03FE51146D8D65F98  # 0.658358977805 954
+    .quad 0x03FE51146D8D65F98
+    .quad 0x03FE5152411D69C03  # 0.658830675927 955
+    .quad 0x03FE5152411D69C03
+    .quad 0x03FE51AF0C774A2D0  # 0.659538640558 956
+    .quad 0x03FE51AF0C774A2D0
+    .quad 0x03FE51ECF2B713F8A  # 0.660010895584 957
+    .quad 0x03FE51ECF2B713F8A
+    .quad 0x03FE522AE0738A3D8  # 0.660483373741 958
+    .quad 0x03FE522AE0738A3D8
+    .quad 0x03FE5268D5AE7CDCB  # 0.660956075239 959
+    .quad 0x03FE5268D5AE7CDCB
+    .quad 0x03FE52A6D269BC600  # 0.661429000289 960
+    .quad 0x03FE52A6D269BC600
+    .quad 0x03FE52E4D6A719F9B  # 0.661902149103 961
+    .quad 0x03FE52E4D6A719F9B
+    .quad 0x03FE5322E26867857  # 0.662375521893 962
+    .quad 0x03FE5322E26867857
+    .quad 0x03FE53800225BA6E2  # 0.663086001497 963
+    .quad 0x03FE53800225BA6E2
+    .quad 0x03FE53BE20B8DA502  # 0.663559935155 964
+    .quad 0x03FE53BE20B8DA502
+    .quad 0x03FE53FC46D64DDD1  # 0.664034093533 965
+    .quad 0x03FE53FC46D64DDD1
+    .quad 0x03FE543A747FE9ED6  # 0.664508476843 966
+    .quad 0x03FE543A747FE9ED6
+    .quad 0x03FE5478A9B78404C  # 0.664983085300 967
+    .quad 0x03FE5478A9B78404C
+    .quad 0x03FE54B6E67EF251C  # 0.665457919117 968
+    .quad 0x03FE54B6E67EF251C
+    .quad 0x03FE54F52AD80BAE9  # 0.665932978509 969
+    .quad 0x03FE54F52AD80BAE9
+    .quad 0x03FE553376C4A7A16  # 0.666408263689 970
+    .quad 0x03FE553376C4A7A16
+    .quad 0x03FE5571CA469E5C9  # 0.666883774872 971
+    .quad 0x03FE5571CA469E5C9
+    .quad 0x03FE55CF55C5A5437  # 0.667597465874 972
+    .quad 0x03FE55CF55C5A5437
+    .quad 0x03FE560DBC45153C7  # 0.668073543008 973
+    .quad 0x03FE560DBC45153C7
+    .quad 0x03FE564C2A6059FE7  # 0.668549846899 974
+    .quad 0x03FE564C2A6059FE7
+    .quad 0x03FE568AA0194EC6E  # 0.669026377763 975
+    .quad 0x03FE568AA0194EC6E
+    .quad 0x03FE56C91D71CF810  # 0.669503135817 976
+    .quad 0x03FE56C91D71CF810
+    .quad 0x03FE5707A26BB8C66  # 0.669980121278 977
+    .quad 0x03FE5707A26BB8C66
+    .quad 0x03FE57462F08E7DF5  # 0.670457334363 978
+    .quad 0x03FE57462F08E7DF5
+    .quad 0x03FE5784C34B3AC30  # 0.670934775289 979
+    .quad 0x03FE5784C34B3AC30
+    .quad 0x03FE57C35F3490183  # 0.671412444273 980
+    .quad 0x03FE57C35F3490183
+    .quad 0x03FE580202C6C7353  # 0.671890341535 981
+    .quad 0x03FE580202C6C7353
+    .quad 0x03FE5840AE03C0204  # 0.672368467291 982
+    .quad 0x03FE5840AE03C0204
+    .quad 0x03FE589EBD437CA31  # 0.673086084831 983
+    .quad 0x03FE589EBD437CA31
+    .quad 0x03FE58DD7BB392B30  # 0.673564782782 984
+    .quad 0x03FE58DD7BB392B30
+    .quad 0x03FE591C41D500163  # 0.674043709994 985
+    .quad 0x03FE591C41D500163
+    .quad 0x03FE595B0FA9A7EF1  # 0.674522866688 986
+    .quad 0x03FE595B0FA9A7EF1
+    .quad 0x03FE5999E5336E121  # 0.675002253082 987
+    .quad 0x03FE5999E5336E121
+    .quad 0x03FE59D8C2743705E  # 0.675481869398 988
+    .quad 0x03FE59D8C2743705E
+    .quad 0x03FE5A17A76DE803B  # 0.675961715857 989
+    .quad 0x03FE5A17A76DE803B
+    .quad 0x03FE5A56942266F7B  # 0.676441792678 990
+    .quad 0x03FE5A56942266F7B
+    .quad 0x03FE5A9588939A810  # 0.676922100084 991
+    .quad 0x03FE5A9588939A810
+    .quad 0x03FE5AD484C369F2D  # 0.677402638296 992
+    .quad 0x03FE5AD484C369F2D
+    .quad 0x03FE5B1388B3BD53E  # 0.677883407536 993
+    .quad 0x03FE5B1388B3BD53E
+    .quad 0x03FE5B5294667D5F7  # 0.678364408027 994
+    .quad 0x03FE5B5294667D5F7
+    .quad 0x03FE5B91A7DD93852  # 0.678845639990 995
+    .quad 0x03FE5B91A7DD93852
+    .quad 0x03FE5BD0C31AE9E9D  # 0.679327103649 996
+    .quad 0x03FE5BD0C31AE9E9D
+    .quad 0x03FE5C2F7A8ED5E5B  # 0.680049734055 997
+    .quad 0x03FE5C2F7A8ED5E5B
+    .quad 0x03FE5C6EA94431EF9  # 0.680531777930 998
+    .quad 0x03FE5C6EA94431EF9
+    .quad 0x03FE5CADDFC6874F5  # 0.681014054284 999
+    .quad 0x03FE5CADDFC6874F5
+    .quad 0x03FE5CED1E17C35C6  # 0.681496563340 1000
+    .quad 0x03FE5CED1E17C35C6
+    .quad 0x03FE5D2C6439D4252  # 0.681979305324 1001
+    .quad 0x03FE5D2C6439D4252
+    .quad 0x03FE5D6BB22EA86F6  # 0.682462280460 1002
+    .quad 0x03FE5D6BB22EA86F6
+    .quad 0x03FE5DAB07F82FB84  # 0.682945488974 1003
+    .quad 0x03FE5DAB07F82FB84
+    .quad 0x03FE5DEA65985A350  # 0.683428931091 1004
+    .quad 0x03FE5DEA65985A350
+    .quad 0x03FE5E29CB1118D32  # 0.683912607038 1005
+    .quad 0x03FE5E29CB1118D32
+    .quad 0x03FE5E6938645D390  # 0.684396517040 1006
+    .quad 0x03FE5E6938645D390
+    .quad 0x03FE5EA8AD9419C5B  # 0.684880661324 1007
+    .quad 0x03FE5EA8AD9419C5B
+    .quad 0x03FE5EE82AA241920  # 0.685365040118 1008
+    .quad 0x03FE5EE82AA241920
+    .quad 0x03FE5F27AF90C8705  # 0.685849653648 1009
+    .quad 0x03FE5F27AF90C8705
+    .quad 0x03FE5F673C61A2ED2  # 0.686334502142 1010
+    .quad 0x03FE5F673C61A2ED2
+    .quad 0x03FE5FA6D116C64F7  # 0.686819585829 1011
+    .quad 0x03FE5FA6D116C64F7
+    .quad 0x03FE5FE66DB228992  # 0.687304904936 1012
+    .quad 0x03FE5FE66DB228992
+    .quad 0x03FE60261235C0874  # 0.687790459692 1013
+    .quad 0x03FE60261235C0874
+    .quad 0x03FE6065BEA385926  # 0.688276250325 1014
+    .quad 0x03FE6065BEA385926
+    .quad 0x03FE60A572FD6FEF1  # 0.688762277066 1015
+    .quad 0x03FE60A572FD6FEF1
+    .quad 0x03FE60E52F45788E4  # 0.689248540144 1016
+    .quad 0x03FE60E52F45788E4
+    .quad 0x03FE6124F37D991D4  # 0.689735039789 1017
+    .quad 0x03FE6124F37D991D4
+    .quad 0x03FE6164BFA7CC06C  # 0.690221776231 1018
+    .quad 0x03FE6164BFA7CC06C
+    .quad 0x03FE61A493C60C729  # 0.690708749700 1019
+    .quad 0x03FE61A493C60C729
+    .quad 0x03FE61E46FDA56466  # 0.691195960429 1020
+    .quad 0x03FE61E46FDA56466
+    .quad 0x03FE622453E6A6263  # 0.691683408647 1021
+    .quad 0x03FE622453E6A6263
+    .quad 0x03FE62643FECF9743  # 0.692171094587 1022
+    .quad 0x03FE62643FECF9743
+    .quad 0x03FE62A433EF4E51A  # 0.692659018480 1023
+    .quad 0x03FE62A433EF4E51A
diff --git a/src/gas/vrda_scaledshifted_logr.S b/src/gas/vrda_scaledshifted_logr.S
new file mode 100644
index 0000000..960460d
--- /dev/null
+++ b/src/gas/vrda_scaledshifted_logr.S
@@ -0,0 +1,2451 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrda_scaledshifted_logr.s
+#
+# An array implementation of the log libm function.
+#  Adapted to provide a scalingi and shifting factor.  This routine is
+#  used by the ACML RNG distribution functions.
+#
+# Prototype:
+#
+#    void vrda_scaledshifted_logr(int n, double *x, double *y, double b,double a);
+#
+#   Computes the natural log of x multiplied by b, plus a.
+# A reduced precision routine.   Uses the intel novel reduction technique
+# with frcpai to compute logs.
+#  Also uses only 3 polynomial terms to acheive52-18= 34 significant digits
+#
+#   This specialized routine does not handle negative numbers, 0, NaNs, or infinity.
+#   This routine is not C99 compliant
+#   This version can compute logs in 26
+#   cycles with n <= 24
+#
+#
+
+
+# define local variable storage offsets
+.equ	p_x,0			# temporary for error checking operation
+.equ	p_idx,0x010		# index storage
+.equ	p_xexp,0x020		# index storage
+
+.equ	p_x2,0x030		# temporary for error checking operation
+.equ	p_idx2,0x040		# index storage
+.equ	p_xexp2,0x050		# index storage
+
+.equ	save_xa,0x060		#qword
+.equ	save_ya,0x068		#qword
+.equ	save_nv,0x070		#qword
+.equ	p_iter,0x078		# qword	storage for number of loop iterations
+
+
+
+.equ	p2_temp,0x090		# second temporary for get/put bits operation
+
+
+
+.equ	stack_size,0x0e8
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+	.weak vrda_scaledshifted_logr__
+	.set vrda_scaledshifted_logr__,__vrda_scaledshifted_logr__
+	.weak vrda_scaledshifted_logr_
+	.set vrda_scaledshifted_logr_,__vrda_scaledshifted_logr__
+
+# Fortran interface parameters are passed in by Linux as:
+# rdi - int n
+# rsi - double *x
+# rdx - double *y
+# rcx - double *b
+# r8 - double *a
+
+    .text
+    .align 16
+    .p2align 4,,15
+
+#x/* a FORTRAN subroutine implementation of array log
+#**     VRDA_LOG(N,X,Y)
+# C equivalent*/
+#void vrda_scaledshifted_logr__(int * n, double *x, double *y,double *b, double *a)
+#{
+#       vrda_scaledshifted_logr(*n,x,y);
+#}
+.globl __vrda_scaledshifted_logr__
+    .type   __vrda_scaledshifted_logr__,@function
+__vrda_scaledshifted_logr__:
+    mov		(%rdi),%edi
+    movlpd	(%rcx),%xmm0
+    movlpd	(%r8),%xmm1
+
+# C interface parameters are passed in by Linux as:
+# rdi - int n
+# rsi - double *x
+# rdx - double *y
+# xmm0 - double b
+# xmm1 - double a
+
+    .align 16
+    .p2align 4,,15
+.globl vrda_scaledshifted_logr
+    .type   vrda_scaledshifted_logr,@function
+vrda_scaledshifted_logr:
+	sub		$stack_size,%rsp
+
+# save the arguments
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+	mov		%rdx,save_ya(%rsp)	# save y_array pointer
+#ifdef INTEGER64
+        mov             %rdi,%rax
+#else
+        mov             %edi,%eax
+        mov             %rax,%rdi
+#endif
+# move the scale and shift factor to another register
+	movsd		%xmm0,%xmm10
+	unpcklpd	%xmm10,%xmm10
+	movsd		%xmm1,%xmm11
+	unpcklpd	%xmm11,%xmm11
+
+	mov		%rdi,save_nv(%rsp)	# save number of values
+# see if too few values to call the main loop
+	shr		$2,%rax			# get number of iterations
+	jz		.L__vda_cleanup		# jump if only single calls
+# prepare the iteration counts
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	shl		$2,%rax
+	sub		%rax,%rdi		# compute number of extra single calls
+	mov		%rdi,save_nv(%rsp)	# save number of left over values
+
+# In this second version, process the array 2 values at a time.
+
+.L__vda_top:
+# build the input _m128d
+	mov		save_xa(%rsp),%rsi	# get x_array pointer
+	movlpd	(%rsi),%xmm0
+	movhpd	8(%rsi),%xmm0
+	prefetch	64(%rsi)
+	add		$32,%rsi
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+
+                movlpd  -16(%rsi),%xmm1
+                movhpd  -8(%rsi),%xmm1
+
+# compute the logs
+
+#	movdqa	%xmm0,p_x(%rsp)	# save the input values
+
+# use the  algorithm referenced in the itanic trancendental paper.
+
+# reduction
+#  compute r = x frcpa(x) - 1
+        movdqa  %xmm0,%xmm8
+        movdqa  %xmm1,%xmm9
+
+        call    __vrd4_frcpa@PLT
+        movdqa  %xmm8,%xmm4
+                movdqa  %xmm9,%xmm7
+# invert the exponent
+        psllq   $1,%xmm8
+                psllq   $1,%xmm9
+        mulpd   %xmm0,%xmm4                             # r
+                mulpd   %xmm1,%xmm7                     # r
+        movdqa  %xmm8,%xmm5
+        paddq   .L__mask_rup(%rip),%xmm8
+        psrlq   $53,%xmm8
+                movdqa  %xmm9,%xmm6
+                paddq   .L__mask_rup(%rip),%xmm6
+                psrlq   $53,%xmm6
+        psubq   .L__mask_3ff(%rip),%xmm8
+                psubq   .L__mask_3ff(%rip),%xmm6
+        pshufd  $0x058,%xmm8,%xmm8
+                pshufd  $0x058,%xmm6,%xmm6
+
+
+        subpd   .L__real_one(%rip),%xmm4
+                subpd   .L__real_one(%rip),%xmm7
+
+        cvtdq2pd        %xmm8,%xmm0             #N
+                cvtdq2pd        %xmm6,%xmm1             #N
+#	movdqa	%xmm8,%xmm0
+#	movdqa	%xmm6,%xmm1
+# compute index for table lookup. if 1/2 bit set, increment the index+exponent
+        psrlq   $42,%xmm5
+                psrlq   $42,%xmm9
+        paddq   .L__int_one(%rip),%xmm5
+                paddq   .L__int_one(%rip),%xmm9
+        psrlq   $1,%xmm5
+                psrlq   $1,%xmm9
+        pand    .L__mask_3ff(%rip),%xmm5
+                pand    .L__mask_3ff(%rip),%xmm9
+        psllq   $1,%xmm5
+                psllq   $1,%xmm9
+
+        movdqa  %xmm5,p_x(%rsp) # move the indexes to a memory location
+                movdqa  %xmm9,p_x2(%rsp)
+
+
+        movapd  .L__real_third(%rip),%xmm3
+                movdqa  %xmm3,%xmm5
+        movapd  %xmm4,%xmm2
+                movapd  %xmm7,%xmm8
+
+# approximation
+#  compute the polynomial
+#   p(r) = p1r^2+p2r^3+p3r^4+p4r^5
+
+        mulpd   %xmm4,%xmm2                     #r^2
+                mulpd   %xmm7,%xmm8                     #r^2
+
+        mulpd   %xmm4,%xmm3                     # 1/3r
+                mulpd   %xmm7,%xmm5                     # 1/3r
+# lookup the f(k) term
+        lea             .L__np_lnf_table(%rip),%rdx
+        mov             p_x(%rsp),%rcx
+        mov             p_x+8(%rsp),%r9
+        movlpd          (%rdx,%rcx,8),%xmm6     # lookup
+        movhpd          (%rdx,%r9,8),%xmm6      # lookup
+
+        addpd   .L__real_half(%rip),%xmm3  # p2 + p3r
+                addpd   .L__real_half(%rip),%xmm5  # p2 + p3r
+
+                mov             p_x2(%rsp),%rcx
+                mov             p_x2+8(%rsp),%r9
+                movlpd          (%rdx,%rcx,8),%xmm9     # lookup
+                movhpd          (%rdx,%r9,8),%xmm9      # lookup
+
+        mulpd   %xmm3,%xmm2                     # r2(p2 + p3r)
+                mulpd   %xmm5,%xmm8                     # r2(p2 + p3r)
+        addpd   %xmm4,%xmm2                     # +r
+                addpd   %xmm7,%xmm8                     # +r
+
+
+#       reconstruction
+#  compute ln(x) = T + r + p(r) where
+#   T = N*ln(2)+ln(1/frcpa(x)) via tab of ln(1/frcpa(y)), where y = 1 + k/256, 0<=k<=255
+
+        mulpd   .L__real_log2(%rip),%xmm0        # compute  N*__real_log2
+                mulpd   .L__real_log2(%rip),%xmm1        # compute  N*__real_log2
+        addpd   %xmm6,%xmm2     # add the new mantissas
+                addpd   %xmm9,%xmm8     # add the new mantissas
+        addpd   %xmm2,%xmm0
+                addpd   %xmm8,%xmm1
+
+
+# store the result _m128d
+	mov		save_ya(%rsp),%rdi	# get y_array pointer
+	mulpd	%xmm10,%xmm0
+	addpd	%xmm11,%xmm0
+	movlpd	%xmm0,(%rdi)
+	movhpd	 %xmm0,8(%rdi)
+
+
+	prefetch	64(%rdi)
+	add		$32,%rdi
+	mov		%rdi,save_ya(%rsp)	# save y_array pointer
+
+# store the result _m128d
+		mulpd	%xmm10,%xmm1
+		addpd	%xmm11,%xmm1
+		movlpd	%xmm1,-16(%rdi)
+		movhpd	%xmm1,-8(%rdi)
+
+	mov		p_iter(%rsp),%rax	# get number of iterations
+	sub		$1,%rax
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	jnz		.L__vda_top
+
+
+# see if we need to do any extras
+	mov		save_nv(%rsp),%rax	# get number of values
+	test		%rax,%rax
+	jnz		.L__vda_cleanup
+
+
+.L__finish:
+	add		$stack_size,%rsp
+	ret
+
+	.align	16
+
+
+
+# we jump here when we have an odd number of log calls to make at the
+# end
+#  we assume that rdx is pointing at the next x array element,
+#  r8 at the next y array element.  The number of values left is in
+#  save_nv
+.L__vda_cleanup:
+        mov             save_nv(%rsp),%rax      # get number of values
+        test            %rax,%rax               # are there any values
+        jz              .L__finish              # exit if not
+
+	mov		save_xa(%rsp),%rsi
+	mov		save_ya(%rsp),%rdi
+
+# fill in a m128d with zeroes and the extra values and then make a recursive call.
+	xorpd		%xmm0,%xmm0
+	movlpd	%xmm0,p_x+8(%rsp)
+	movapd	%xmm0,p_x+16(%rsp)
+
+	mov		(%rsi),%rcx			# we know there's at least one
+	mov	 	%rcx,p_x(%rsp)
+	cmp		$2,%rax
+	jl		.L__vdacg
+
+	mov		8(%rsi),%rcx			# do the second value
+	mov	 	%rcx,p_x+8(%rsp)
+	cmp		$3,%rax
+	jl		.L__vdacg
+
+	mov		16(%rsi),%rcx			# do the third value
+	mov	 	%rcx,p_x+16(%rsp)
+
+.L__vdacg:
+	mov		$4,%rdi				# parameter for N
+	lea		p_x(%rsp),%rsi		# &x parameter
+	lea		p2_temp(%rsp),%rdx	# &y parameter
+        movsd           %xmm10,%xmm0
+        movsd           %xmm11,%xmm1
+	call		vrda_scaledshifted_logr@PLT		# call recursively to compute four values
+
+# now copy the results to the destination array
+	mov		save_ya(%rsp),%rdi
+	mov		save_nv(%rsp),%rax	# get number of values
+	mov	 	p2_temp(%rsp),%rcx
+	mov		%rcx,(%rdi)			# we know there's at least one
+	cmp		$2,%rax
+	jl		.L__vdacgf
+
+	mov	 	p2_temp+8(%rsp),%rcx
+	mov		%rcx,8(%rdi)			# do the second value
+	cmp		$3,%rax
+	jl		.L__vdacgf
+
+	mov	 	p2_temp+16(%rsp),%rcx
+	mov		%rcx,16(%rdi)			# do the third value
+
+.L__vdacgf:
+	jmp		.L__finish
+
+	.data
+	.align	64
+
+.L__real_one:		.quad 0x03ff0000000000000	# 1.0
+			.quad 0x03ff0000000000000
+
+.L__real_half:		.quad 0x0bfe0000000000000	# 1/2
+			.quad 0x0bfe0000000000000
+.L__real_third:		.quad 0x03fd5555555555555	# 1/3
+			.quad 0x03fd5555555555555
+.L__real_fourth:	.quad 0x0bfd0000000000000	# 1/4
+			.quad 0x0bfd0000000000000
+.L__real_fifth:		.quad 0x03fc999999999999a	# 1/5
+			.quad 0x03fc999999999999a
+.L__real_sixth:		.quad 0x0bfc5555555555555	# 1/6
+			.quad 0x0bfc5555555555555
+
+.L__real_log2:	        .quad 0x03FE62E42FEFA39EF  # 0.693147182465
+		        .quad 0x03FE62E42FEFA39EF
+
+.L__mask_3ff:		.quad 0x000000000000003ff	#
+			.quad 0x000000000000003ff
+
+.L__mask_rup:           .quad 0x0000003fffffffffe
+                        .quad 0x0000003fffffffffe
+
+.L__int_one:		.quad 0x00000000000000001
+			.quad 0x00000000000000001
+
+
+
+.L__mask_10bits:	.quad 0x000000000000003ff
+			.quad 0x000000000000003ff
+
+.L__mask_expext:	.quad 0x000000000003ff000
+			.quad 0x000000000003ff000
+
+.L__mask_expext2:	.quad 0x000000000003ff800
+			.quad 0x000000000003ff800
+
+
+
+
+.L__np_lnf_table:
+#log table Program - logtab.c
+#Built Jan 18 2006  09:51:57
+#Compiler version  1400
+
+    .quad 0x00000000000000000  # 0.000000000000 0
+    .quad 0x00000000000000000
+    .quad 0x03F50020055655885  # 0.000977039648 1
+    .quad 0x03F50020055655885
+    .quad 0x03F60040155D5881E  # 0.001955034836 2
+    .quad 0x03F60040155D5881E
+    .quad 0x03F6809048289860A  # 0.002933987435 3
+    .quad 0x03F6809048289860A
+    .quad 0x03F70080559588B25  # 0.003913899321 4
+    .quad 0x03F70080559588B25
+    .quad 0x03F740C8A7478788D  # 0.004894772377 5
+    .quad 0x03F740C8A7478788D
+    .quad 0x03F78121214586B02  # 0.005876608489 6
+    .quad 0x03F78121214586B02
+    .quad 0x03F7C189CBB0E283F  # 0.006859409551 7
+    .quad 0x03F7C189CBB0E283F
+    .quad 0x03F8010157588DE69  # 0.007843177461 8
+    .quad 0x03F8010157588DE69
+    .quad 0x03F82145E939EF1BC  # 0.008827914124 9
+    .quad 0x03F82145E939EF1BC
+    .quad 0x03F83D8896A83D7A8  # 0.009690354884 10
+    .quad 0x03F83D8896A83D7A8
+    .quad 0x03F85DDC705054DFF  # 0.010676913110 11
+    .quad 0x03F85DDC705054DFF
+    .quad 0x03F87E38762CA0C6D  # 0.011664445593 12
+    .quad 0x03F87E38762CA0C6D
+    .quad 0x03F89E9CAC6007563  # 0.012652954261 13
+    .quad 0x03F89E9CAC6007563
+    .quad 0x03F8BF091710935A4  # 0.013642441046 14
+    .quad 0x03F8BF091710935A4
+    .quad 0x03F8DF7DBA6777895  # 0.014632907884 15
+    .quad 0x03F8DF7DBA6777895
+    .quad 0x03F8FBEA8B13C03F9  # 0.015500371846 16
+    .quad 0x03F8FBEA8B13C03F9
+    .quad 0x03F90E3751F24F45C  # 0.016492681528 17
+    .quad 0x03F90E3751F24F45C
+    .quad 0x03F91E7D80B1FBF4C  # 0.017485976867 18
+    .quad 0x03F91E7D80B1FBF4C
+    .quad 0x03F92CBE4F6CC56C3  # 0.018355920375 19
+    .quad 0x03F92CBE4F6CC56C3
+    .quad 0x03F93D0C443D7258C  # 0.019351069108 20
+    .quad 0x03F93D0C443D7258C
+    .quad 0x03F94D5E6176ACC89  # 0.020347209148 21
+    .quad 0x03F94D5E6176ACC89
+    .quad 0x03F95DB4A937DEF10  # 0.021344342472 22
+    .quad 0x03F95DB4A937DEF10
+    .quad 0x03F96C039490E37F4  # 0.022217650494 23
+    .quad 0x03F96C039490E37F4
+    .quad 0x03F97C61B1CF5DED7  # 0.023216651576 24
+    .quad 0x03F97C61B1CF5DED7
+    .quad 0x03F98AB77B3FD6EAD  # 0.024091596947 25
+    .quad 0x03F98AB77B3FD6EAD
+    .quad 0x03F99B1D75828E780  # 0.025092472797 26
+    .quad 0x03F99B1D75828E780
+    .quad 0x03F9AB87A478CB7CB  # 0.026094351403 27
+    .quad 0x03F9AB87A478CB7CB
+    .quad 0x03F9B9E8027E1916F  # 0.026971819338 28
+    .quad 0x03F9B9E8027E1916F
+    .quad 0x03F9CA5A1A18613E6  # 0.027975583538 29
+    .quad 0x03F9CA5A1A18613E6
+    .quad 0x03F9D8C1670325921  # 0.028854704473 30
+    .quad 0x03F9D8C1670325921
+    .quad 0x03F9E93B6EE41F674  # 0.029860361378 31
+    .quad 0x03F9E93B6EE41F674
+    .quad 0x03F9F7A9B16782855  # 0.030741141554 32
+    .quad 0x03F9F7A9B16782855
+    .quad 0x03FA0415D89E74440  # 0.031748698315 33
+    .quad 0x03FA0415D89E74440
+    .quad 0x03FA0C58FA19DFAAB  # 0.032757271269 34
+    .quad 0x03FA0C58FA19DFAAB
+    .quad 0x03FA139577CC41C1A  # 0.033640607815 35
+    .quad 0x03FA139577CC41C1A
+    .quad 0x03FA1AD398C6CD57C  # 0.034524725334 36
+    .quad 0x03FA1AD398C6CD57C
+    .quad 0x03FA231C9C40E204E  # 0.035536103423 37
+    .quad 0x03FA231C9C40E204E
+    .quad 0x03FA2A5E4231CF7BD  # 0.036421899115 38
+    .quad 0x03FA2A5E4231CF7BD
+    .quad 0x03FA32AB4D4C59CB0  # 0.037435198758 39
+    .quad 0x03FA32AB4D4C59CB0
+    .quad 0x03FA39F07BA0EBD5A  # 0.038322679007 40
+    .quad 0x03FA39F07BA0EBD5A
+    .quad 0x03FA424192495D571  # 0.039337907520 41
+    .quad 0x03FA424192495D571
+    .quad 0x03FA498A4C73DA65D  # 0.040227078744 42
+    .quad 0x03FA498A4C73DA65D
+    .quad 0x03FA50D4AF75CA86F  # 0.041117041297 43
+    .quad 0x03FA50D4AF75CA86F
+    .quad 0x03FA592BBC15215BC  # 0.042135112141 44
+    .quad 0x03FA592BBC15215BC
+    .quad 0x03FA6079B00423FF6  # 0.043026775152 45
+    .quad 0x03FA6079B00423FF6
+    .quad 0x03FA67C94F2D4BB65  # 0.043919233935 46
+    .quad 0x03FA67C94F2D4BB65
+    .quad 0x03FA70265A550E77B  # 0.044940163069 47
+    .quad 0x03FA70265A550E77B
+    .quad 0x03FA77798F8D6DFDC  # 0.045834331871 48
+    .quad 0x03FA77798F8D6DFDC
+    .quad 0x03FA7ECE7267CD123  # 0.046729300926 49
+    .quad 0x03FA7ECE7267CD123
+    .quad 0x03FA873184BC09586  # 0.047753104446 50
+    .quad 0x03FA873184BC09586
+    .quad 0x03FA8E8A02D2E3175  # 0.048649793163 51
+    .quad 0x03FA8E8A02D2E3175
+    .quad 0x03FA95E430F8CE456  # 0.049547286652 52
+    .quad 0x03FA95E430F8CE456
+    .quad 0x03FA9D400FF482586  # 0.050445586359 53
+    .quad 0x03FA9D400FF482586
+    .quad 0x03FAA5AB21CB34A9E  # 0.051473203662 54
+    .quad 0x03FAA5AB21CB34A9E
+    .quad 0x03FAAD0AA2E784EF4  # 0.052373235867 55
+    .quad 0x03FAAD0AA2E784EF4
+    .quad 0x03FAB46BD74DA76A0  # 0.053274078860 56
+    .quad 0x03FAB46BD74DA76A0
+    .quad 0x03FABBCEBFC68F424  # 0.054175734102 57
+    .quad 0x03FABBCEBFC68F424
+    .quad 0x03FAC3335D1BBAE4D  # 0.055078203060 58
+    .quad 0x03FAC3335D1BBAE4D
+    .quad 0x03FACBA87200EB8F1  # 0.056110594428 59
+    .quad 0x03FACBA87200EB8F1
+    .quad 0x03FAD310BA20455A2  # 0.057014812019 60
+    .quad 0x03FAD310BA20455A2
+    .quad 0x03FADA7AB998B77ED  # 0.057919847959 61
+    .quad 0x03FADA7AB998B77ED
+    .quad 0x03FAE1E6713606CFB  # 0.058825703731 62
+    .quad 0x03FAE1E6713606CFB
+    .quad 0x03FAE953E1C48603A  # 0.059732380822 63
+    .quad 0x03FAE953E1C48603A
+    .quad 0x03FAF0C30C1116351  # 0.060639880722 64
+    .quad 0x03FAF0C30C1116351
+    .quad 0x03FAF833F0E927711  # 0.061548204926 65
+    .quad 0x03FAF833F0E927711
+    .quad 0x03FAFFA6911AB9309  # 0.062457354934 66
+    .quad 0x03FAFFA6911AB9309
+    .quad 0x03FB038D76BA2D737  # 0.063367332247 67
+    .quad 0x03FB038D76BA2D737
+    .quad 0x03FB0748836296412  # 0.064278138373 68
+    .quad 0x03FB0748836296412
+    .quad 0x03FB0B046EEE6F7A4  # 0.065189774824 69
+    .quad 0x03FB0B046EEE6F7A4
+    .quad 0x03FB0EC139C5DA5FD  # 0.066102243114 70
+    .quad 0x03FB0EC139C5DA5FD
+    .quad 0x03FB127EE451413A8  # 0.067015544762 71
+    .quad 0x03FB127EE451413A8
+    .quad 0x03FB163D6EF9579FC  # 0.067929681294 72
+    .quad 0x03FB163D6EF9579FC
+    .quad 0x03FB19FCDA271ABC0  # 0.068844654235 73
+    .quad 0x03FB19FCDA271ABC0
+    .quad 0x03FB1DBD2643D1912  # 0.069760465119 74
+    .quad 0x03FB1DBD2643D1912
+    .quad 0x03FB217E53B90D3CE  # 0.070677115481 75
+    .quad 0x03FB217E53B90D3CE
+    .quad 0x03FB254062F0A9417  # 0.071594606862 76
+    .quad 0x03FB254062F0A9417
+    .quad 0x03FB29035454CBCB0  # 0.072512940806 77
+    .quad 0x03FB29035454CBCB0
+    .quad 0x03FB2CC7284FE5F1A  # 0.073432118863 78
+    .quad 0x03FB2CC7284FE5F1A
+    .quad 0x03FB308BDF4CB4062  # 0.074352142586 79
+    .quad 0x03FB308BDF4CB4062
+    .quad 0x03FB345179B63DD3F  # 0.075273013532 80
+    .quad 0x03FB345179B63DD3F
+    .quad 0x03FB3817F7F7D6EAB  # 0.076194733263 81
+    .quad 0x03FB3817F7F7D6EAB
+    .quad 0x03FB3BDF5A7D1EE5E  # 0.077117303344 82
+    .quad 0x03FB3BDF5A7D1EE5E
+    .quad 0x03FB3F1D405CE86D3  # 0.077908755701 83
+    .quad 0x03FB3F1D405CE86D3
+    .quad 0x03FB42E64BEC266E4  # 0.078832909176 84
+    .quad 0x03FB42E64BEC266E4
+    .quad 0x03FB46B03CF437BC4  # 0.079757917501 85
+    .quad 0x03FB46B03CF437BC4
+    .quad 0x03FB4A7B13E1E3E65  # 0.080683782259 86
+    .quad 0x03FB4A7B13E1E3E65
+    .quad 0x03FB4E46D1223FE84  # 0.081610505036 87
+    .quad 0x03FB4E46D1223FE84
+    .quad 0x03FB52137522AE732  # 0.082538087426 88
+    .quad 0x03FB52137522AE732
+    .quad 0x03FB5555DE434F2A0  # 0.083333843436 89
+    .quad 0x03FB5555DE434F2A0
+    .quad 0x03FB59242FF043D34  # 0.084263026485 90
+    .quad 0x03FB59242FF043D34
+    .quad 0x03FB5CF36997817B2  # 0.085193073719 91
+    .quad 0x03FB5CF36997817B2
+    .quad 0x03FB60C38BA799459  # 0.086123986746 92
+    .quad 0x03FB60C38BA799459
+    .quad 0x03FB6408F471C82A2  # 0.086922602521 93
+    .quad 0x03FB6408F471C82A2
+    .quad 0x03FB67DAC7466CB96  # 0.087855127734 94
+    .quad 0x03FB67DAC7466CB96
+    .quad 0x03FB6BAD83C1883BA  # 0.088788523361 95
+    .quad 0x03FB6BAD83C1883BA
+    .quad 0x03FB6EF528C056A2D  # 0.089589270768 96
+    .quad 0x03FB6EF528C056A2D
+    .quad 0x03FB72C9985035BB1  # 0.090524287199 97
+    .quad 0x03FB72C9985035BB1
+    .quad 0x03FB769EF2C6B5688  # 0.091460178704 98
+    .quad 0x03FB769EF2C6B5688
+    .quad 0x03FB79E8D70A364C6  # 0.092263069152 99
+    .quad 0x03FB79E8D70A364C6
+    .quad 0x03FB7DBFE6EA733FE  # 0.093200590148 100
+    .quad 0x03FB7DBFE6EA733FE
+    .quad 0x03FB8197E2F40E3F0  # 0.094138990914 101
+    .quad 0x03FB8197E2F40E3F0
+    .quad 0x03FB84E40992A4804  # 0.094944035906 102
+    .quad 0x03FB84E40992A4804
+    .quad 0x03FB88BDBD5FC66D2  # 0.095884074919 103
+    .quad 0x03FB88BDBD5FC66D2
+    .quad 0x03FB8C985E9B9EC7E  # 0.096824998438 104
+    .quad 0x03FB8C985E9B9EC7E
+    .quad 0x03FB8FE6CAB20E979  # 0.097632209567 105
+    .quad 0x03FB8FE6CAB20E979
+    .quad 0x03FB93C3261014C65  # 0.098574780162 106
+    .quad 0x03FB93C3261014C65
+    .quad 0x03FB97130DC9235DE  # 0.099383405543 107
+    .quad 0x03FB97130DC9235DE
+    .quad 0x03FB9AF124D64C623  # 0.100327628989 108
+    .quad 0x03FB9AF124D64C623
+    .quad 0x03FB9E4289871E964  # 0.101137673586 109
+    .quad 0x03FB9E4289871E964
+    .quad 0x03FBA2225DD276FCB  # 0.102083555691 110
+    .quad 0x03FBA2225DD276FCB
+    .quad 0x03FBA57540D1FE441  # 0.102895024494 111
+    .quad 0x03FBA57540D1FE441
+    .quad 0x03FBA956D3ECADE60  # 0.103842571097 112
+    .quad 0x03FBA956D3ECADE60
+    .quad 0x03FBACAB3693AB9C0  # 0.104655469123 113
+    .quad 0x03FBACAB3693AB9C0
+    .quad 0x03FBB08E8A10F96F4  # 0.105604686090 114
+    .quad 0x03FBB08E8A10F96F4
+    .quad 0x03FBB3E46DBA02181  # 0.106419018383 115
+    .quad 0x03FBB3E46DBA02181
+    .quad 0x03FBB7C9832F58018  # 0.107369911615 116
+    .quad 0x03FBB7C9832F58018
+    .quad 0x03FBBB20E936D6976  # 0.108185683244 117
+    .quad 0x03FBBB20E936D6976
+    .quad 0x03FBBF07C23BC54EA  # 0.109138258671 118
+    .quad 0x03FBBF07C23BC54EA
+    .quad 0x03FBC260ABFFFE972  # 0.109955474734 119
+    .quad 0x03FBC260ABFFFE972
+    .quad 0x03FBC6494A2E418A0  # 0.110909738320 120
+    .quad 0x03FBC6494A2E418A0
+    .quad 0x03FBC9A3B90F57748  # 0.111728403941 121
+    .quad 0x03FBC9A3B90F57748
+    .quad 0x03FBCCFEDBFEE13A8  # 0.112547740324 122
+    .quad 0x03FBCCFEDBFEE13A8
+    .quad 0x03FBD0EA1362CDBFC  # 0.113504482008 123
+    .quad 0x03FBD0EA1362CDBFC
+    .quad 0x03FBD446BD753D433  # 0.114325275488 124
+    .quad 0x03FBD446BD753D433
+    .quad 0x03FBD7A41C8627307  # 0.115146743223 125
+    .quad 0x03FBD7A41C8627307
+    .quad 0x03FBDB91F09680DF9  # 0.116105975911 126
+    .quad 0x03FBDB91F09680DF9
+    .quad 0x03FBDEF0D8D466DBB  # 0.116928908339 127
+    .quad 0x03FBDEF0D8D466DBB
+    .quad 0x03FBE2507702AF03B  # 0.117752518544 128
+    .quad 0x03FBE2507702AF03B
+    .quad 0x03FBE640EB3D2B411  # 0.118714255240 129
+    .quad 0x03FBE640EB3D2B411
+    .quad 0x03FBE9A214A69DD58  # 0.119539337795 130
+    .quad 0x03FBE9A214A69DD58
+    .quad 0x03FBED03F4F440969  # 0.120365101673 131
+    .quad 0x03FBED03F4F440969
+    .quad 0x03FBF0F70CDD992E4  # 0.121329355484 132
+    .quad 0x03FBF0F70CDD992E4
+    .quad 0x03FBF45A7A78B7C3B  # 0.122156599431 133
+    .quad 0x03FBF45A7A78B7C3B
+    .quad 0x03FBF7BE9FEDBFDED  # 0.122984528276 134
+    .quad 0x03FBF7BE9FEDBFDED
+    .quad 0x03FBFB237D8AB13FB  # 0.123813143156 135
+    .quad 0x03FBFB237D8AB13FB
+    .quad 0x03FBFF1A13EAC95FD  # 0.124780729104 136
+    .quad 0x03FBFF1A13EAC95FD
+    .quad 0x03FC014040CAB0229  # 0.125610834299 137
+    .quad 0x03FC014040CAB0229
+    .quad 0x03FC02F3D4301417B  # 0.126441629140 138
+    .quad 0x03FC02F3D4301417B
+    .quad 0x03FC04A7C44CF87A4  # 0.127273114776 139
+    .quad 0x03FC04A7C44CF87A4
+    .quad 0x03FC06A4D1D26C5E9  # 0.128244055971 140
+    .quad 0x03FC06A4D1D26C5E9
+    .quad 0x03FC08598B59E3A07  # 0.129077042275 141
+    .quad 0x03FC08598B59E3A07
+    .quad 0x03FC0A0EA2164AF02  # 0.129910723024 142
+    .quad 0x03FC0A0EA2164AF02
+    .quad 0x03FC0BC4162F73B66  # 0.130745099376 143
+    .quad 0x03FC0BC4162F73B66
+    .quad 0x03FC0D79E7CD48E58  # 0.131580172493 144
+    .quad 0x03FC0D79E7CD48E58
+    .quad 0x03FC0F301717CF0FB  # 0.132415943541 145
+    .quad 0x03FC0F301717CF0FB
+    .quad 0x03FC10E6A437247B7  # 0.133252413686 146
+    .quad 0x03FC10E6A437247B7
+    .quad 0x03FC12E6BFA8FEAD6  # 0.134229180665 147
+    .quad 0x03FC12E6BFA8FEAD6
+    .quad 0x03FC149E189F8642E  # 0.135067169541 148
+    .quad 0x03FC149E189F8642E
+    .quad 0x03FC1655CFEA923A4  # 0.135905861231 149
+    .quad 0x03FC1655CFEA923A4
+    .quad 0x03FC180DE5B2ACE5C  # 0.136745256915 150
+    .quad 0x03FC180DE5B2ACE5C
+    .quad 0x03FC19C65A207AC07  # 0.137585357777 151
+    .quad 0x03FC19C65A207AC07
+    .quad 0x03FC1B7F2D5CBA842  # 0.138426165001 152
+    .quad 0x03FC1B7F2D5CBA842
+    .quad 0x03FC1D385F90453F2  # 0.139267679777 153
+    .quad 0x03FC1D385F90453F2
+    .quad 0x03FC1EF1F0E40E6CD  # 0.140109903297 154
+    .quad 0x03FC1EF1F0E40E6CD
+    .quad 0x03FC20ABE18124098  # 0.140952836755 155
+    .quad 0x03FC20ABE18124098
+    .quad 0x03FC22663190AEACC  # 0.141796481350 156
+    .quad 0x03FC22663190AEACC
+    .quad 0x03FC2420E13BF19E3  # 0.142640838281 157
+    .quad 0x03FC2420E13BF19E3
+    .quad 0x03FC25DBF0AC4AED2  # 0.143485908754 158
+    .quad 0x03FC25DBF0AC4AED2
+    .quad 0x03FC2797600B3387B  # 0.144331693975 159
+    .quad 0x03FC2797600B3387B
+    .quad 0x03FC29532F823F525  # 0.145178195155 160
+    .quad 0x03FC29532F823F525
+    .quad 0x03FC2B0F5F3B1D3EF  # 0.146025413505 161
+    .quad 0x03FC2B0F5F3B1D3EF
+    .quad 0x03FC2CCBEF5F97653  # 0.146873350243 162
+    .quad 0x03FC2CCBEF5F97653
+    .quad 0x03FC2E88E01993187  # 0.147722006588 163
+    .quad 0x03FC2E88E01993187
+    .quad 0x03FC3046319311009  # 0.148571383763 164
+    .quad 0x03FC3046319311009
+    .quad 0x03FC3203E3F62D328  # 0.149421482992 165
+    .quad 0x03FC3203E3F62D328
+    .quad 0x03FC33C1F76D1F469  # 0.150272305505 166
+    .quad 0x03FC33C1F76D1F469
+    .quad 0x03FC35806C223A70F  # 0.151123852534 167
+    .quad 0x03FC35806C223A70F
+    .quad 0x03FC373F423FED9A1  # 0.151976125313 168
+    .quad 0x03FC373F423FED9A1
+    .quad 0x03FC38FE79F0C3771  # 0.152829125080 169
+    .quad 0x03FC38FE79F0C3771
+    .quad 0x03FC3ABE135F62A12  # 0.153682853077 170
+    .quad 0x03FC3ABE135F62A12
+    .quad 0x03FC3C335E0447D71  # 0.154394850259 171
+    .quad 0x03FC3C335E0447D71
+    .quad 0x03FC3DF3AB13505F9  # 0.155249916579 172
+    .quad 0x03FC3DF3AB13505F9
+    .quad 0x03FC3FB45A59928CA  # 0.156105714663 173
+    .quad 0x03FC3FB45A59928CA
+    .quad 0x03FC41756C0220C81  # 0.156962245765 174
+    .quad 0x03FC41756C0220C81
+    .quad 0x03FC4336E03829D61  # 0.157819511141 175
+    .quad 0x03FC4336E03829D61
+    .quad 0x03FC44F8B726F8EFE  # 0.158677512051 176
+    .quad 0x03FC44F8B726F8EFE
+    .quad 0x03FC46BAF0F9F5DB8  # 0.159536249760 177
+    .quad 0x03FC46BAF0F9F5DB8
+    .quad 0x03FC48326CD3EC797  # 0.160252428262 178
+    .quad 0x03FC48326CD3EC797
+    .quad 0x03FC49F55C6502F81  # 0.161112520058 179
+    .quad 0x03FC49F55C6502F81
+    .quad 0x03FC4BB8AF55DE908  # 0.161973352249 180
+    .quad 0x03FC4BB8AF55DE908
+    .quad 0x03FC4D7C65D25566D  # 0.162834926111 181
+    .quad 0x03FC4D7C65D25566D
+    .quad 0x03FC4F4080065AA7F  # 0.163697242922 182
+    .quad 0x03FC4F4080065AA7F
+    .quad 0x03FC50B98CD30A759  # 0.164416408720 183
+    .quad 0x03FC50B98CD30A759
+    .quad 0x03FC527E5E4A1B58D  # 0.165280090939 184
+    .quad 0x03FC527E5E4A1B58D
+    .quad 0x03FC544393F5DF80F  # 0.166144519750 185
+    .quad 0x03FC544393F5DF80F
+    .quad 0x03FC56092E02BA514  # 0.167009696444 186
+    .quad 0x03FC56092E02BA514
+    .quad 0x03FC57837B3098F2C  # 0.167731249257 187
+    .quad 0x03FC57837B3098F2C
+    .quad 0x03FC5949CDB873419  # 0.168597800437 188
+    .quad 0x03FC5949CDB873419
+    .quad 0x03FC5B10851FC924A  # 0.169465103180 189
+    .quad 0x03FC5B10851FC924A
+    .quad 0x03FC5C8BC079D8289  # 0.170188430518 190
+    .quad 0x03FC5C8BC079D8289
+    .quad 0x03FC5E533144C1718  # 0.171057114516 191
+    .quad 0x03FC5E533144C1718
+    .quad 0x03FC601B076E7A8A8  # 0.171926553783 192
+    .quad 0x03FC601B076E7A8A8
+    .quad 0x03FC619732215D786  # 0.172651664394 193
+    .quad 0x03FC619732215D786
+    .quad 0x03FC635FC298F6C77  # 0.173522491735 194
+    .quad 0x03FC635FC298F6C77
+    .quad 0x03FC6528B8EFA5D16  # 0.174394078077 195
+    .quad 0x03FC6528B8EFA5D16
+    .quad 0x03FC66A5D42A3AD33  # 0.175120980777 196
+    .quad 0x03FC66A5D42A3AD33
+    .quad 0x03FC686F85BAD4298  # 0.175993962063 197
+    .quad 0x03FC686F85BAD4298
+    .quad 0x03FC6A399DABBD383  # 0.176867706111 198
+    .quad 0x03FC6A399DABBD383
+    .quad 0x03FC6BB7AA9F22C40  # 0.177596409780 199
+    .quad 0x03FC6BB7AA9F22C40
+    .quad 0x03FC6D827EB7C1E57  # 0.178471555693 200
+    .quad 0x03FC6D827EB7C1E57
+    .quad 0x03FC6F0128B756AB9  # 0.179201429458 201
+    .quad 0x03FC6F0128B756AB9
+    .quad 0x03FC70CCB9927BCF6  # 0.180077981742 202
+    .quad 0x03FC70CCB9927BCF6
+    .quad 0x03FC7298B1A4E32B6  # 0.180955303044 203
+    .quad 0x03FC7298B1A4E32B6
+    .quad 0x03FC74184F58CC7DC  # 0.181686992547 204
+    .quad 0x03FC74184F58CC7DC
+    .quad 0x03FC75E5051E74141  # 0.182565727226 205
+    .quad 0x03FC75E5051E74141
+    .quad 0x03FC77654128F6127  # 0.183298596442 206
+    .quad 0x03FC77654128F6127
+    .quad 0x03FC7932B53E97639  # 0.184178749058 207
+    .quad 0x03FC7932B53E97639
+    .quad 0x03FC7AB390229D8FD  # 0.184912801796 208
+    .quad 0x03FC7AB390229D8FD
+    .quad 0x03FC7C81C325B4A5E  # 0.185794376934 209
+    .quad 0x03FC7C81C325B4A5E
+    .quad 0x03FC7E033D66CD24A  # 0.186529617023 210
+    .quad 0x03FC7E033D66CD24A
+    .quad 0x03FC7FD22FF599D4C  # 0.187412619288 211
+    .quad 0x03FC7FD22FF599D4C
+    .quad 0x03FC81544A17F67C1  # 0.188149050576 212
+    .quad 0x03FC81544A17F67C1
+    .quad 0x03FC8323FCD17DAC8  # 0.189033484595 213
+    .quad 0x03FC8323FCD17DAC8
+    .quad 0x03FC84A6B759F512D  # 0.189771110947 214
+    .quad 0x03FC84A6B759F512D
+    .quad 0x03FC86772ADE0201C  # 0.190656981373 215
+    .quad 0x03FC86772ADE0201C
+    .quad 0x03FC87FA865210911  # 0.191395806674 216
+    .quad 0x03FC87FA865210911
+    .quad 0x03FC89CBBB4136201  # 0.192283118179 217
+    .quad 0x03FC89CBBB4136201
+    .quad 0x03FC8B4FB826FF291  # 0.193023146334 218
+    .quad 0x03FC8B4FB826FF291
+    .quad 0x03FC8D21AF2299298  # 0.193911903613 219
+    .quad 0x03FC8D21AF2299298
+    .quad 0x03FC8EA64E00E7FC0  # 0.194653138545 220
+    .quad 0x03FC8EA64E00E7FC0
+    .quad 0x03FC902B36AB7681D  # 0.195394923313 221
+    .quad 0x03FC902B36AB7681D
+    .quad 0x03FC91FE49096581E  # 0.196285791969 222
+    .quad 0x03FC91FE49096581E
+    .quad 0x03FC9383D471B869B  # 0.197028789254 223
+    .quad 0x03FC9383D471B869B
+    .quad 0x03FC9557AA6B87F65  # 0.197921115309 224
+    .quad 0x03FC9557AA6B87F65
+    .quad 0x03FC96DDD91A0B959  # 0.198665329082 225
+    .quad 0x03FC96DDD91A0B959
+    .quad 0x03FC9864522D04491  # 0.199410097121 226
+    .quad 0x03FC9864522D04491
+    .quad 0x03FC9A3945D1A44B3  # 0.200304551564 227
+    .quad 0x03FC9A3945D1A44B3
+    .quad 0x03FC9BC062F26FC3B  # 0.201050541900 228
+    .quad 0x03FC9BC062F26FC3B
+    .quad 0x03FC9D47CAD2C1871  # 0.201797089154 229
+    .quad 0x03FC9D47CAD2C1871
+    .quad 0x03FC9F1DDD7FE4F8B  # 0.202693682161 230
+    .quad 0x03FC9F1DDD7FE4F8B
+    .quad 0x03FCA0A5EA371A910  # 0.203441457564 231
+    .quad 0x03FCA0A5EA371A910
+    .quad 0x03FCA22E42098F498  # 0.204189792554 232
+    .quad 0x03FCA22E42098F498
+    .quad 0x03FCA405751F6CCE4  # 0.205088534376 233
+    .quad 0x03FCA405751F6CCE4
+    .quad 0x03FCA58E729348F40  # 0.205838103409 234
+    .quad 0x03FCA58E729348F40
+    .quad 0x03FCA717BB7EC64A3  # 0.206588234717 235
+    .quad 0x03FCA717BB7EC64A3
+    .quad 0x03FCA8F010601E5FD  # 0.207489135679 236
+    .quad 0x03FCA8F010601E5FD
+    .quad 0x03FCAA79FFB8FCD48  # 0.208240506966 237
+    .quad 0x03FCAA79FFB8FCD48
+    .quad 0x03FCAC043AE68965A  # 0.208992443238 238
+    .quad 0x03FCAC043AE68965A
+    .quad 0x03FCAD8EC205FB6AD  # 0.209744945343 239
+    .quad 0x03FCAD8EC205FB6AD
+    .quad 0x03FCAF6895610DBAD  # 0.210648695969 240
+    .quad 0x03FCAF6895610DBAD
+    .quad 0x03FCB0F3C3FBD65C9  # 0.211402445910 241
+    .quad 0x03FCB0F3C3FBD65C9
+    .quad 0x03FCB27F3EE674219  # 0.212156764419 242
+    .quad 0x03FCB27F3EE674219
+    .quad 0x03FCB40B063E65B0F  # 0.212911652354 243
+    .quad 0x03FCB40B063E65B0F
+    .quad 0x03FCB5E65A8096C88  # 0.213818270730 244
+    .quad 0x03FCB5E65A8096C88
+    .quad 0x03FCB772CA646760C  # 0.214574414434 245
+    .quad 0x03FCB772CA646760C
+    .quad 0x03FCB8FF871461198  # 0.215331130323 246
+    .quad 0x03FCB8FF871461198
+    .quad 0x03FCBA8C90AE4AD19  # 0.216088419265 247
+    .quad 0x03FCBA8C90AE4AD19
+    .quad 0x03FCBC19E74FFCBDA  # 0.216846282128 248
+    .quad 0x03FCBC19E74FFCBDA
+    .quad 0x03FCBDF71B83DAE7A  # 0.217756476365 249
+    .quad 0x03FCBDF71B83DAE7A
+    .quad 0x03FCBF851C067555C  # 0.218515604922 250
+    .quad 0x03FCBF851C067555C
+    .quad 0x03FCC11369F0CDB3C  # 0.219275310193 251
+    .quad 0x03FCC11369F0CDB3C
+    .quad 0x03FCC2A205610593E  # 0.220035593055 252
+    .quad 0x03FCC2A205610593E
+    .quad 0x03FCC430EE755023B  # 0.220796454387 253
+    .quad 0x03FCC430EE755023B
+    .quad 0x03FCC5C0254BF23A8  # 0.221557895069 254
+    .quad 0x03FCC5C0254BF23A8
+    .quad 0x03FCC79F9AB632BF1  # 0.222472389875 255
+    .quad 0x03FCC79F9AB632BF1
+    .quad 0x03FCC92F7D09ABE20  # 0.223235108240 256
+    .quad 0x03FCC92F7D09ABE20
+    .quad 0x03FCCABFAD80D023D  # 0.223998408788 257
+    .quad 0x03FCCABFAD80D023D
+    .quad 0x03FCCC502C3A2F1E8  # 0.224762292410 258
+    .quad 0x03FCCC502C3A2F1E8
+    .quad 0x03FCCDE0F9546A5E7  # 0.225526759995 259
+    .quad 0x03FCCDE0F9546A5E7
+    .quad 0x03FCCF7214EE356E9  # 0.226291812439 260
+    .quad 0x03FCCF7214EE356E9
+    .quad 0x03FCD1037F2655E7B  # 0.227057450635 261
+    .quad 0x03FCD1037F2655E7B
+    .quad 0x03FCD295381BA37E9  # 0.227823675483 262
+    .quad 0x03FCD295381BA37E9
+    .quad 0x03FCD4273FED08111  # 0.228590487882 263
+    .quad 0x03FCD4273FED08111
+    .quad 0x03FCD5B996B97FB5F  # 0.229357888733 264
+    .quad 0x03FCD5B996B97FB5F
+    .quad 0x03FCD74C3CA018C9C  # 0.230125878940 265
+    .quad 0x03FCD74C3CA018C9C
+    .quad 0x03FCD8DF31BFF3FF2  # 0.230894459410 266
+    .quad 0x03FCD8DF31BFF3FF2
+    .quad 0x03FCDA727638446A1  # 0.231663631050 267
+    .quad 0x03FCDA727638446A1
+    .quad 0x03FCDC56CAE452F5B  # 0.232587418645 268
+    .quad 0x03FCDC56CAE452F5B
+    .quad 0x03FCDDEABE5A3926E  # 0.233357894066 269
+    .quad 0x03FCDDEABE5A3926E
+    .quad 0x03FCDF7F018CE771F  # 0.234128963578 270
+    .quad 0x03FCDF7F018CE771F
+    .quad 0x03FCE113949BDEC62  # 0.234900628096 271
+    .quad 0x03FCE113949BDEC62
+    .quad 0x03FCE2A877A6B2C0F  # 0.235672888541 272
+    .quad 0x03FCE2A877A6B2C0F
+    .quad 0x03FCE43DAACD09BEC  # 0.236445745833 273
+    .quad 0x03FCE43DAACD09BEC
+    .quad 0x03FCE5D32E2E9CE87  # 0.237219200895 274
+    .quad 0x03FCE5D32E2E9CE87
+    .quad 0x03FCE76901EB38427  # 0.237993254653 275
+    .quad 0x03FCE76901EB38427
+    .quad 0x03FCE8ADE53F76866  # 0.238612929343 276
+    .quad 0x03FCE8ADE53F76866
+    .quad 0x03FCEA4449F04AAF4  # 0.239388063093 277
+    .quad 0x03FCEA4449F04AAF4
+    .quad 0x03FCEBDAFF5593E99  # 0.240163798141 278
+    .quad 0x03FCEBDAFF5593E99
+    .quad 0x03FCED72058F666C5  # 0.240940135421 279
+    .quad 0x03FCED72058F666C5
+    .quad 0x03FCEF095CBDE9937  # 0.241717075868 280
+    .quad 0x03FCEF095CBDE9937
+    .quad 0x03FCF0A1050157ED6  # 0.242494620422 281
+    .quad 0x03FCF0A1050157ED6
+    .quad 0x03FCF238FE79FF4BF  # 0.243272770021 282
+    .quad 0x03FCF238FE79FF4BF
+    .quad 0x03FCF3D1494840D2F  # 0.244051525609 283
+    .quad 0x03FCF3D1494840D2F
+    .quad 0x03FCF569E58C91077  # 0.244830888130 284
+    .quad 0x03FCF569E58C91077
+    .quad 0x03FCF702D36777DF0  # 0.245610858531 285
+    .quad 0x03FCF702D36777DF0
+    .quad 0x03FCF89C12F990D0C  # 0.246391437760 286
+    .quad 0x03FCF89C12F990D0C
+    .quad 0x03FCFA35A4638AE2C  # 0.247172626770 287
+    .quad 0x03FCFA35A4638AE2C
+    .quad 0x03FCFB7D86EEE3B92  # 0.247798017660 288
+    .quad 0x03FCFB7D86EEE3B92
+    .quad 0x03FCFD17ABFCDB683  # 0.248580306677 289
+    .quad 0x03FCFD17ABFCDB683
+    .quad 0x03FCFEB2233EA07CB  # 0.249363208150 290
+    .quad 0x03FCFEB2233EA07CB
+    .quad 0x03FD0026766A9671C  # 0.250146723037 291
+    .quad 0x03FD0026766A9671C
+    .quad 0x03FD00F40470C7323  # 0.250930852302 292
+    .quad 0x03FD00F40470C7323
+    .quad 0x03FD01C1BBC2735A3  # 0.251715596908 293
+    .quad 0x03FD01C1BBC2735A3
+    .quad 0x03FD028F9C7035C1D  # 0.252500957822 294
+    .quad 0x03FD028F9C7035C1D
+    .quad 0x03FD03346E0106062  # 0.253129690945 295
+    .quad 0x03FD03346E0106062
+    .quad 0x03FD0402994B4F041  # 0.253916163656 296
+    .quad 0x03FD0402994B4F041
+    .quad 0x03FD04D0EE20620AF  # 0.254703255393 297
+    .quad 0x03FD04D0EE20620AF
+    .quad 0x03FD059F6C910034D  # 0.255490967131 298
+    .quad 0x03FD059F6C910034D
+    .quad 0x03FD066E14ADF4BFD  # 0.256279299848 299
+    .quad 0x03FD066E14ADF4BFD
+    .quad 0x03FD07138604D5864  # 0.256910413785 300
+    .quad 0x03FD07138604D5864
+    .quad 0x03FD07E2794F3E8C1  # 0.257699866735 301
+    .quad 0x03FD07E2794F3E8C1
+    .quad 0x03FD08B196753A125  # 0.258489943414 302
+    .quad 0x03FD08B196753A125
+    .quad 0x03FD0980DD87BA2DD  # 0.259280644807 303
+    .quad 0x03FD0980DD87BA2DD
+    .quad 0x03FD0A504E97BB40C  # 0.260071971904 304
+    .quad 0x03FD0A504E97BB40C
+    .quad 0x03FD0AF660EB9E278  # 0.260705484754 305
+    .quad 0x03FD0AF660EB9E278
+    .quad 0x03FD0BC61DBBA97CB  # 0.261497940616 306
+    .quad 0x03FD0BC61DBBA97CB
+    .quad 0x03FD0C9604B8FC51E  # 0.262291024962 307
+    .quad 0x03FD0C9604B8FC51E
+    .quad 0x03FD0D3C7586CD5E5  # 0.262925945618 308
+    .quad 0x03FD0D3C7586CD5E5
+    .quad 0x03FD0E0CA89A72D29  # 0.263720163752 309
+    .quad 0x03FD0E0CA89A72D29
+    .quad 0x03FD0EDD060B78082  # 0.264515013170 310
+    .quad 0x03FD0EDD060B78082
+    .quad 0x03FD0FAD8DEB1E2C0  # 0.265310494876 311
+    .quad 0x03FD0FAD8DEB1E2C0
+    .quad 0x03FD10547F9D26ABC  # 0.265947336165 312
+    .quad 0x03FD10547F9D26ABC
+    .quad 0x03FD1125540925114  # 0.266743958529 313
+    .quad 0x03FD1125540925114
+    .quad 0x03FD11F653144CB8B  # 0.267541216005 314
+    .quad 0x03FD11F653144CB8B
+    .quad 0x03FD129DA43F5BE9E  # 0.268179479949 315
+    .quad 0x03FD129DA43F5BE9E
+    .quad 0x03FD136EF02E8290C  # 0.268977883185 316
+    .quad 0x03FD136EF02E8290C
+    .quad 0x03FD144066EDAE406  # 0.269776924378 317
+    .quad 0x03FD144066EDAE406
+    .quad 0x03FD14E817FF359D7  # 0.270416617347 318
+    .quad 0x03FD14E817FF359D7
+    .quad 0x03FD15B9DBFA9DEC8  # 0.271216809436 319
+    .quad 0x03FD15B9DBFA9DEC8
+    .quad 0x03FD168BCAF73B3EB  # 0.272017642345 320
+    .quad 0x03FD168BCAF73B3EB
+    .quad 0x03FD1733DC5D68DE8  # 0.272658770753 321
+    .quad 0x03FD1733DC5D68DE8
+    .quad 0x03FD180618EF18ADE  # 0.273460759729 322
+    .quad 0x03FD180618EF18ADE
+    .quad 0x03FD18D880B3826FE  # 0.274263392407 323
+    .quad 0x03FD18D880B3826FE
+    .quad 0x03FD1980F2DD42B6F  # 0.274905962710 324
+    .quad 0x03FD1980F2DD42B6F
+    .quad 0x03FD1A53A8902E70B  # 0.275709756661 325
+    .quad 0x03FD1A53A8902E70B
+    .quad 0x03FD1AFC59297024D  # 0.276353257326 326
+    .quad 0x03FD1AFC59297024D
+    .quad 0x03FD1BCF5D04AE1EA  # 0.277158215914 327
+    .quad 0x03FD1BCF5D04AE1EA
+    .quad 0x03FD1CA28C64BAE54  # 0.277963822983 328
+    .quad 0x03FD1CA28C64BAE54
+    .quad 0x03FD1D4B9E796C245  # 0.278608776246 329
+    .quad 0x03FD1D4B9E796C245
+    .quad 0x03FD1E1F1C5C3A06C  # 0.279415553216 330
+    .quad 0x03FD1E1F1C5C3A06C
+    .quad 0x03FD1EC86D5747AAD  # 0.280061443760 331
+    .quad 0x03FD1EC86D5747AAD
+    .quad 0x03FD1F9C39F74C559  # 0.280869394034 332
+    .quad 0x03FD1F9C39F74C559
+    .quad 0x03FD2070326F1F789  # 0.281677997620 333
+    .quad 0x03FD2070326F1F789
+    .quad 0x03FD2119E59F8789C  # 0.282325351583 334
+    .quad 0x03FD2119E59F8789C
+    .quad 0x03FD21EE2D300381C  # 0.283135133796 335
+    .quad 0x03FD21EE2D300381C
+    .quad 0x03FD22981FBEF797A  # 0.283783432036 336
+    .quad 0x03FD22981FBEF797A
+    .quad 0x03FD236CB6A339EED  # 0.284594396317 337
+    .quad 0x03FD236CB6A339EED
+    .quad 0x03FD2416E8C01F606  # 0.285243641592 338
+    .quad 0x03FD2416E8C01F606
+    .quad 0x03FD24EBCF3387FF6  # 0.286055791397 339
+    .quad 0x03FD24EBCF3387FF6
+    .quad 0x03FD2596410DF963A  # 0.286705986479 340
+    .quad 0x03FD2596410DF963A
+    .quad 0x03FD266B774C2AF55  # 0.287519325279 341
+    .quad 0x03FD266B774C2AF55
+    .quad 0x03FD27162913F873F  # 0.288170472950 342
+    .quad 0x03FD27162913F873F
+    .quad 0x03FD27EBAF58D8C9C  # 0.288985004232 343
+    .quad 0x03FD27EBAF58D8C9C
+    .quad 0x03FD2896A13E086A3  # 0.289637107288 344
+    .quad 0x03FD2896A13E086A3
+    .quad 0x03FD296C77C5C0E13  # 0.290452834554 345
+    .quad 0x03FD296C77C5C0E13
+    .quad 0x03FD2A17A9F88EDD2  # 0.291105895801 346
+    .quad 0x03FD2A17A9F88EDD2
+    .quad 0x03FD2AEDD0FF8CC2C  # 0.291922822568 347
+    .quad 0x03FD2AEDD0FF8CC2C
+    .quad 0x03FD2B9943B06BD77  # 0.292576844829 348
+    .quad 0x03FD2B9943B06BD77
+    .quad 0x03FD2C6FBB7360D0E  # 0.293394974630 349
+    .quad 0x03FD2C6FBB7360D0E
+    .quad 0x03FD2D1B6ED2FA90C  # 0.294049960734 350
+    .quad 0x03FD2D1B6ED2FA90C
+    .quad 0x03FD2DC73F01B0DD4  # 0.294705376127 351
+    .quad 0x03FD2DC73F01B0DD4
+    .quad 0x03FD2E9E2BCE12286  # 0.295525249913 352
+    .quad 0x03FD2E9E2BCE12286
+    .quad 0x03FD2F4A3CF22EDC2  # 0.296181633264 353
+    .quad 0x03FD2F4A3CF22EDC2
+    .quad 0x03FD30217B1006601  # 0.297002718785 354
+    .quad 0x03FD30217B1006601
+    .quad 0x03FD30CDCD5ABA762  # 0.297660072959 355
+    .quad 0x03FD30CDCD5ABA762
+    .quad 0x03FD31A55D07A8590  # 0.298482373803 356
+    .quad 0x03FD31A55D07A8590
+    .quad 0x03FD3251F0AA5CC1A  # 0.299140701674 357
+    .quad 0x03FD3251F0AA5CC1A
+    .quad 0x03FD32FEA167A6D70  # 0.299799463226 358
+    .quad 0x03FD32FEA167A6D70
+    .quad 0x03FD33D6A7509D491  # 0.300623525901 359
+    .quad 0x03FD33D6A7509D491
+    .quad 0x03FD348399ADA9D94  # 0.301283265328 360
+    .quad 0x03FD348399ADA9D94
+    .quad 0x03FD3530A9454ADC9  # 0.301943440298 361
+    .quad 0x03FD3530A9454ADC9
+    .quad 0x03FD360925EC44F5C  # 0.302769272371 362
+    .quad 0x03FD360925EC44F5C
+    .quad 0x03FD36B6776BE1116  # 0.303430429420 363
+    .quad 0x03FD36B6776BE1116
+    .quad 0x03FD378F469437FB4  # 0.304257490918 364
+    .quad 0x03FD378F469437FB4
+    .quad 0x03FD383CDA2E14ECB  # 0.304919632971 365
+    .quad 0x03FD383CDA2E14ECB
+    .quad 0x03FD38EA8B3924521  # 0.305582213748 366
+    .quad 0x03FD38EA8B3924521
+    .quad 0x03FD39C3D1FD60E74  # 0.306411057558 367
+    .quad 0x03FD39C3D1FD60E74
+    .quad 0x03FD3A71C56BB48C7  # 0.307074627589 368
+    .quad 0x03FD3A71C56BB48C7
+    .quad 0x03FD3B1FD66BC8D10  # 0.307738638238 369
+    .quad 0x03FD3B1FD66BC8D10
+    .quad 0x03FD3BF995502CB5C  # 0.308569272059 370
+    .quad 0x03FD3BF995502CB5C
+    .quad 0x03FD3CA7E8FD01DF6  # 0.309234276240 371
+    .quad 0x03FD3CA7E8FD01DF6
+    .quad 0x03FD3D565A5C5BF11  # 0.309899722945 372
+    .quad 0x03FD3D565A5C5BF11
+    .quad 0x03FD3E3091E6049FB  # 0.310732154526 373
+    .quad 0x03FD3E3091E6049FB
+    .quad 0x03FD3EDF463C1683E  # 0.311398599069 374
+    .quad 0x03FD3EDF463C1683E
+    .quad 0x03FD3F8E1865A82DD  # 0.312065488057 375
+    .quad 0x03FD3F8E1865A82DD
+    .quad 0x03FD403D086CEA79B  # 0.312732822082 376
+    .quad 0x03FD403D086CEA79B
+    .quad 0x03FD4117DE854CA15  # 0.313567616354 377
+    .quad 0x03FD4117DE854CA15
+    .quad 0x03FD41C711E4BA15E  # 0.314235953889 378
+    .quad 0x03FD41C711E4BA15E
+    .quad 0x03FD427663431B221  # 0.314904738398 379
+    .quad 0x03FD427663431B221
+    .quad 0x03FD4325D2AAB6F18  # 0.315573970480 380
+    .quad 0x03FD4325D2AAB6F18
+    .quad 0x03FD44014838E5513  # 0.316411140893 381
+    .quad 0x03FD44014838E5513
+    .quad 0x03FD44B0FB5AF4F44  # 0.317081382205 382
+    .quad 0x03FD44B0FB5AF4F44
+    .quad 0x03FD4560CCA7CB3B2  # 0.317752073041 383
+    .quad 0x03FD4560CCA7CB3B2
+    .quad 0x03FD4610BC29C5E18  # 0.318423214006 384
+    .quad 0x03FD4610BC29C5E18
+    .quad 0x03FD46ECD216CDCB5  # 0.319262774126 385
+    .quad 0x03FD46ECD216CDCB5
+    .quad 0x03FD479D05B65CB60  # 0.319934930091 386
+    .quad 0x03FD479D05B65CB60
+    .quad 0x03FD484D57ACE5A1A  # 0.320607538154 387
+    .quad 0x03FD484D57ACE5A1A
+    .quad 0x03FD48FDC804DD1CB  # 0.321280598924 388
+    .quad 0x03FD48FDC804DD1CB
+    .quad 0x03FD49DA7F3BCC420  # 0.322122562432 389
+    .quad 0x03FD49DA7F3BCC420
+    .quad 0x03FD4A8B341552B09  # 0.322796644021 390
+    .quad 0x03FD4A8B341552B09
+    .quad 0x03FD4B3C077267E9A  # 0.323471180303 391
+    .quad 0x03FD4B3C077267E9A
+    .quad 0x03FD4BECF95D97914  # 0.324146171892 392
+    .quad 0x03FD4BECF95D97914
+    .quad 0x03FD4C9E09E172C3D  # 0.324821619401 393
+    .quad 0x03FD4C9E09E172C3D
+    .quad 0x03FD4D4F3908901A0  # 0.325497523449 394
+    .quad 0x03FD4D4F3908901A0
+    .quad 0x03FD4E2CDF1F341C1  # 0.326343046455 395
+    .quad 0x03FD4E2CDF1F341C1
+    .quad 0x03FD4EDE535C79642  # 0.327019979972 396
+    .quad 0x03FD4EDE535C79642
+    .quad 0x03FD4F8FE65F90500  # 0.327697372039 397
+    .quad 0x03FD4F8FE65F90500
+    .quad 0x03FD5041983326F2D  # 0.328375223276 398
+    .quad 0x03FD5041983326F2D
+    .quad 0x03FD50F368E1F0F02  # 0.329053534308 399
+    .quad 0x03FD50F368E1F0F02
+    .quad 0x03FD51A55876A77F5  # 0.329732305758 400
+    .quad 0x03FD51A55876A77F5
+    .quad 0x03FD5283EF743F98B  # 0.330581418486 401
+    .quad 0x03FD5283EF743F98B
+    .quad 0x03FD533624B59CA35  # 0.331261228165 402
+    .quad 0x03FD533624B59CA35
+    .quad 0x03FD53E878FFE6EAE  # 0.331941500300 403
+    .quad 0x03FD53E878FFE6EAE
+    .quad 0x03FD549AEC5DEF880  # 0.332622235521 404
+    .quad 0x03FD549AEC5DEF880
+    .quad 0x03FD554D7EDA8D3C4  # 0.333303434457 405
+    .quad 0x03FD554D7EDA8D3C4
+    .quad 0x03FD560030809C759  # 0.333985097742 406
+    .quad 0x03FD560030809C759
+    .quad 0x03FD56B3015AFF52C  # 0.334667226008 407
+    .quad 0x03FD56B3015AFF52C
+    .quad 0x03FD5765F1749DA6C  # 0.335349819892 408
+    .quad 0x03FD5765F1749DA6C
+    .quad 0x03FD581900D864FD7  # 0.336032880027 409
+    .quad 0x03FD581900D864FD7
+    .quad 0x03FD58CC2F91489F5  # 0.336716407053 410
+    .quad 0x03FD58CC2F91489F5
+    .quad 0x03FD59AC5618CCE38  # 0.337571473373 411
+    .quad 0x03FD59AC5618CCE38
+    .quad 0x03FD5A5FCB795780C  # 0.338256053239 412
+    .quad 0x03FD5A5FCB795780C
+    .quad 0x03FD5B136052BCE39  # 0.338941102075 413
+    .quad 0x03FD5B136052BCE39
+    .quad 0x03FD5BC714B008E23  # 0.339626620526 414
+    .quad 0x03FD5BC714B008E23
+    .quad 0x03FD5C7AE89C4D254  # 0.340312609234 415
+    .quad 0x03FD5C7AE89C4D254
+    .quad 0x03FD5D2EDC22A12BA  # 0.340999068845 416
+    .quad 0x03FD5D2EDC22A12BA
+    .quad 0x03FD5DE2EF4E224D6  # 0.341686000008 417
+    .quad 0x03FD5DE2EF4E224D6
+    .quad 0x03FD5E972229F3C15  # 0.342373403369 418
+    .quad 0x03FD5E972229F3C15
+    .quad 0x03FD5F4B74C13EA04  # 0.343061279578 419
+    .quad 0x03FD5F4B74C13EA04
+    .quad 0x03FD5FFFE71F31E9A  # 0.343749629287 420
+    .quad 0x03FD5FFFE71F31E9A
+    .quad 0x03FD60B4794F02875  # 0.344438453147 421
+    .quad 0x03FD60B4794F02875
+    .quad 0x03FD61692B5BEB520  # 0.345127751813 422
+    .quad 0x03FD61692B5BEB520
+    .quad 0x03FD621DFD512D14F  # 0.345817525940 423
+    .quad 0x03FD621DFD512D14F
+    .quad 0x03FD62D2EF3A0E933  # 0.346507776183 424
+    .quad 0x03FD62D2EF3A0E933
+    .quad 0x03FD63880121DC8AB  # 0.347198503200 425
+    .quad 0x03FD63880121DC8AB
+    .quad 0x03FD643D3313E9B92  # 0.347889707652 426
+    .quad 0x03FD643D3313E9B92
+    .quad 0x03FD64F2851B8EE01  # 0.348581390197 427
+    .quad 0x03FD64F2851B8EE01
+    .quad 0x03FD65A7F7442AC90  # 0.349273551498 428
+    .quad 0x03FD65A7F7442AC90
+    .quad 0x03FD665D8999224A5  # 0.349966192218 429
+    .quad 0x03FD665D8999224A5
+    .quad 0x03FD67133C25E04A5  # 0.350659313022 430
+    .quad 0x03FD67133C25E04A5
+    .quad 0x03FD67C90EF5D5C4C  # 0.351352914576 431
+    .quad 0x03FD67C90EF5D5C4C
+    .quad 0x03FD687F021479CEE  # 0.352046997547 432
+    .quad 0x03FD687F021479CEE
+    .quad 0x03FD6935158D499B3  # 0.352741562603 433
+    .quad 0x03FD6935158D499B3
+    .quad 0x03FD69EB496BC87E5  # 0.353436610416 434
+    .quad 0x03FD69EB496BC87E5
+    .quad 0x03FD6AA19DBB7FF34  # 0.354132141656 435
+    .quad 0x03FD6AA19DBB7FF34
+    .quad 0x03FD6B581287FF9FD  # 0.354828156996 436
+    .quad 0x03FD6B581287FF9FD
+    .quad 0x03FD6C0EA7DCDD591  # 0.355524657112 437
+    .quad 0x03FD6C0EA7DCDD591
+    .quad 0x03FD6C97AD3CFCFD9  # 0.356047350738 438
+    .quad 0x03FD6C97AD3CFCFD9
+    .quad 0x03FD6D4E7B9C727EC  # 0.356744700836 439
+    .quad 0x03FD6D4E7B9C727EC
+    .quad 0x03FD6E056AA4421D6  # 0.357442537571 440
+    .quad 0x03FD6E056AA4421D6
+    .quad 0x03FD6EBC7A6019066  # 0.358140861621 441
+    .quad 0x03FD6EBC7A6019066
+    .quad 0x03FD6F73AADBAAAB7  # 0.358839673669 442
+    .quad 0x03FD6F73AADBAAAB7
+    .quad 0x03FD702AFC22B0C6D  # 0.359538974397 443
+    .quad 0x03FD702AFC22B0C6D
+    .quad 0x03FD70E26E40EB5FA  # 0.360238764489 444
+    .quad 0x03FD70E26E40EB5FA
+    .quad 0x03FD719A014220CF5  # 0.360939044629 445
+    .quad 0x03FD719A014220CF5
+    .quad 0x03FD7251B5321DC54  # 0.361639815506 446
+    .quad 0x03FD7251B5321DC54
+    .quad 0x03FD73098A1CB54BA  # 0.362341077807 447
+    .quad 0x03FD73098A1CB54BA
+    .quad 0x03FD73937F783CEBA  # 0.362867347444 448
+    .quad 0x03FD73937F783CEBA
+    .quad 0x03FD744B8E35E9EDA  # 0.363569471398 449
+    .quad 0x03FD744B8E35E9EDA
+    .quad 0x03FD7503BE0ED6C66  # 0.364272088676 450
+    .quad 0x03FD7503BE0ED6C66
+    .quad 0x03FD75BC0F0EEE7DE  # 0.364975199972 451
+    .quad 0x03FD75BC0F0EEE7DE
+    .quad 0x03FD76748142228C7  # 0.365678805982 452
+    .quad 0x03FD76748142228C7
+    .quad 0x03FD772D14B46AE00  # 0.366382907402 453
+    .quad 0x03FD772D14B46AE00
+    .quad 0x03FD77E5C971C5E06  # 0.367087504930 454
+    .quad 0x03FD77E5C971C5E06
+    .quad 0x03FD787066E04915F  # 0.367616279067 455
+    .quad 0x03FD787066E04915F
+    .quad 0x03FD792955FDF47A3  # 0.368321746469 456
+    .quad 0x03FD792955FDF47A3
+    .quad 0x03FD79E26687CFB3D  # 0.369027711906 457
+    .quad 0x03FD79E26687CFB3D
+    .quad 0x03FD7A9B9889F19E2  # 0.369734176082 458
+    .quad 0x03FD7A9B9889F19E2
+    .quad 0x03FD7B54EC1077A48  # 0.370441139703 459
+    .quad 0x03FD7B54EC1077A48
+    .quad 0x03FD7C0E612785C74  # 0.371148603475 460
+    .quad 0x03FD7C0E612785C74
+    .quad 0x03FD7C998F06FB152  # 0.371679529954 461
+    .quad 0x03FD7C998F06FB152
+    .quad 0x03FD7D533EF841E8A  # 0.372387870696 462
+    .quad 0x03FD7D533EF841E8A
+    .quad 0x03FD7E0D109B95F19  # 0.373096713539 463
+    .quad 0x03FD7E0D109B95F19
+    .quad 0x03FD7EC703FD340AA  # 0.373806059198 464
+    .quad 0x03FD7EC703FD340AA
+    .quad 0x03FD7F8119295FB9B  # 0.374515908385 465
+    .quad 0x03FD7F8119295FB9B
+    .quad 0x03FD800CBF3ED1CC2  # 0.375048626146 466
+    .quad 0x03FD800CBF3ED1CC2
+    .quad 0x03FD80C70FAB0BDF6  # 0.375759358229 467
+    .quad 0x03FD80C70FAB0BDF6
+    .quad 0x03FD81818203AFC7F  # 0.376470595813 468
+    .quad 0x03FD81818203AFC7F
+    .quad 0x03FD823C16551A3C3  # 0.377182339615 469
+    .quad 0x03FD823C16551A3C3
+    .quad 0x03FD82C81BE4DFF4A  # 0.377716480107 470
+    .quad 0x03FD82C81BE4DFF4A
+    .quad 0x03FD8382EBC7794D1  # 0.378429111528 471
+    .quad 0x03FD8382EBC7794D1
+    .quad 0x03FD843DDDC4FB137  # 0.379142251156 472
+    .quad 0x03FD843DDDC4FB137
+    .quad 0x03FD84F8F1E9DB72B  # 0.379855899714 473
+    .quad 0x03FD84F8F1E9DB72B
+    .quad 0x03FD85855776DCBFB  # 0.380391470556 474
+    .quad 0x03FD85855776DCBFB
+    .quad 0x03FD8640A77EB3957  # 0.381106011494 475
+    .quad 0x03FD8640A77EB3957
+    .quad 0x03FD86FC19D05148E  # 0.381821063366 476
+    .quad 0x03FD86FC19D05148E
+    .quad 0x03FD87B7AE7845C0F  # 0.382536626902 477
+    .quad 0x03FD87B7AE7845C0F
+    .quad 0x03FD8844748678822  # 0.383073635776 478
+    .quad 0x03FD8844748678822
+    .quad 0x03FD89004563D3DFD  # 0.383790096491 479
+    .quad 0x03FD89004563D3DFD
+    .quad 0x03FD89BC38BA356B4  # 0.384507070890 480
+    .quad 0x03FD89BC38BA356B4
+    .quad 0x03FD8A4945E20894E  # 0.385045139237 481
+    .quad 0x03FD8A4945E20894E
+    .quad 0x03FD8B0575AAB1FC5  # 0.385763014358 482
+    .quad 0x03FD8B0575AAB1FC5
+    .quad 0x03FD8BC1C80F45A32  # 0.386481405193 483
+    .quad 0x03FD8BC1C80F45A32
+    .quad 0x03FD8C7E3D1C80B2F  # 0.387200312485 484
+    .quad 0x03FD8C7E3D1C80B2F
+    .quad 0x03FD8D0BABACC89EE  # 0.387739832326 485
+    .quad 0x03FD8D0BABACC89EE
+    .quad 0x03FD8DC85D7FE5013  # 0.388459645206 486
+    .quad 0x03FD8DC85D7FE5013
+    .quad 0x03FD8E85321ED5598  # 0.389179976589 487
+    .quad 0x03FD8E85321ED5598
+    .quad 0x03FD8F12E873862C7  # 0.389720565845 488
+    .quad 0x03FD8F12E873862C7
+    .quad 0x03FD8FCFFA1614AA0  # 0.390441806410 489
+    .quad 0x03FD8FCFFA1614AA0
+    .quad 0x03FD908D2EA7D9511  # 0.391163567538 490
+    .quad 0x03FD908D2EA7D9511
+    .quad 0x03FD911B2D09ED9D6  # 0.391705230456 491
+    .quad 0x03FD911B2D09ED9D6
+    .quad 0x03FD91D89EDD6B7FF  # 0.392427904381 492
+    .quad 0x03FD91D89EDD6B7FF
+    .quad 0x03FD929633C3B7D3E  # 0.393151100941 493
+    .quad 0x03FD929633C3B7D3E
+    .quad 0x03FD93247A7C99B52  # 0.393693841796 494
+    .quad 0x03FD93247A7C99B52
+    .quad 0x03FD93E24CE3195E8  # 0.394417954789 495
+    .quad 0x03FD93E24CE3195E8
+    .quad 0x03FD9470C1CB1962E  # 0.394961383840 496
+    .quad 0x03FD9470C1CB1962E
+    .quad 0x03FD952ED1D9C0435  # 0.395686415592 497
+    .quad 0x03FD952ED1D9C0435
+    .quad 0x03FD95ED0535EA5D9  # 0.396411973396 498
+    .quad 0x03FD95ED0535EA5D9
+    .quad 0x03FD967BC2EDCCE17  # 0.396956487431 499
+    .quad 0x03FD967BC2EDCCE17
+    .quad 0x03FD973A3431356AE  # 0.397682967666 500
+    .quad 0x03FD973A3431356AE
+    .quad 0x03FD97F8C8E64A1C7  # 0.398409976059 501
+    .quad 0x03FD97F8C8E64A1C7
+    .quad 0x03FD9887CFB8A3932  # 0.398955579419 502
+    .quad 0x03FD9887CFB8A3932
+    .quad 0x03FD9946A2946EF3C  # 0.399683513937 503
+    .quad 0x03FD9946A2946EF3C
+    .quad 0x03FD99D5D8130607C  # 0.400229812776 504
+    .quad 0x03FD99D5D8130607C
+    .quad 0x03FD9A94E93E1EC37  # 0.400958675782 505
+    .quad 0x03FD9A94E93E1EC37
+    .quad 0x03FD9B244D87735E8  # 0.401505671875 506
+    .quad 0x03FD9B244D87735E8
+    .quad 0x03FD9BE39D2A97F0B  # 0.402235465741 507
+    .quad 0x03FD9BE39D2A97F0B
+    .quad 0x03FD9CA3109266E23  # 0.402965792595 508
+    .quad 0x03FD9CA3109266E23
+    .quad 0x03FD9D32BEA15ED3A  # 0.403513887977 509
+    .quad 0x03FD9D32BEA15ED3A
+    .quad 0x03FD9DF270C1914A8  # 0.404245149435 510
+    .quad 0x03FD9DF270C1914A8
+    .quad 0x03FD9E824DEA3E135  # 0.404793946669 511
+    .quad 0x03FD9E824DEA3E135
+    .quad 0x03FD9F423EEBF9DA1  # 0.405526145127 512
+    .quad 0x03FD9F423EEBF9DA1
+    .quad 0x03FD9FD24B4D47012  # 0.406075646011 513
+    .quad 0x03FD9FD24B4D47012
+    .quad 0x03FDA0927B59DA6E2  # 0.406808783874 514
+    .quad 0x03FDA0927B59DA6E2
+    .quad 0x03FDA152CF7F3B46D  # 0.407542459622 515
+    .quad 0x03FDA152CF7F3B46D
+    .quad 0x03FDA1E32653B420E  # 0.408093069896 516
+    .quad 0x03FDA1E32653B420E
+    .quad 0x03FDA2A3B9C527DB1  # 0.408827688845 517
+    .quad 0x03FDA2A3B9C527DB1
+    .quad 0x03FDA33440224FA79  # 0.409379007429 518
+    .quad 0x03FDA33440224FA79
+    .quad 0x03FDA3F513098DD09  # 0.410114572008 519
+    .quad 0x03FDA3F513098DD09
+    .quad 0x03FDA485C90EBDB0C  # 0.410666600728 520
+    .quad 0x03FDA485C90EBDB0C
+    .quad 0x03FDA546DB95A721A  # 0.411403113374 521
+    .quad 0x03FDA546DB95A721A
+    .quad 0x03FDA5D7C16257437  # 0.411955854060 522
+    .quad 0x03FDA5D7C16257437
+    .quad 0x03FDA69913B2F6572  # 0.412693317221 523
+    .quad 0x03FDA69913B2F6572
+    .quad 0x03FDA72A2966BE1EA  # 0.413246771713 524
+    .quad 0x03FDA72A2966BE1EA
+    .quad 0x03FDA7EBBBAB46E8B  # 0.413985187844 525
+    .quad 0x03FDA7EBBBAB46E8B
+    .quad 0x03FDA87D0165DD199  # 0.414539357989 526
+    .quad 0x03FDA87D0165DD199
+    .quad 0x03FDA93ED3C8AD9E3  # 0.415278729556 527
+    .quad 0x03FDA93ED3C8AD9E3
+    .quad 0x03FDA9D049A9E884A  # 0.415833617206 528
+    .quad 0x03FDA9D049A9E884A
+    .quad 0x03FDAA925C5588EFA  # 0.416573946686 529
+    .quad 0x03FDAA925C5588EFA
+    .quad 0x03FDAB24027D5E8AF  # 0.417129553701 530
+    .quad 0x03FDAB24027D5E8AF
+    .quad 0x03FDABE6559C8167C  # 0.417870843580 531
+    .quad 0x03FDABE6559C8167C
+    .quad 0x03FDAC782C2B07944  # 0.418427171828 532
+    .quad 0x03FDAC782C2B07944
+    .quad 0x03FDAD3ABFE88A06E  # 0.419169424599 533
+    .quad 0x03FDAD3ABFE88A06E
+    .quad 0x03FDADCCC6FDF6A80  # 0.419726475955 534
+    .quad 0x03FDADCCC6FDF6A80
+    .quad 0x03FDAE5EE2E961227  # 0.420283837790 535
+    .quad 0x03FDAE5EE2E961227
+    .quad 0x03FDAF21D34189D0A  # 0.421027470470 536
+    .quad 0x03FDAF21D34189D0A
+    .quad 0x03FDAFB41FE2167B4  # 0.421585558104 537
+    .quad 0x03FDAFB41FE2167B4
+    .quad 0x03FDB07751416A7F3  # 0.422330159776 538
+    .quad 0x03FDB07751416A7F3
+    .quad 0x03FDB109CEB79DB8A  # 0.422888975102 539
+    .quad 0x03FDB109CEB79DB8A
+    .quad 0x03FDB1CD41498DF12  # 0.423634548296 540
+    .quad 0x03FDB1CD41498DF12
+    .quad 0x03FDB25FEFB60CB2E  # 0.424194093214 541
+    .quad 0x03FDB25FEFB60CB2E
+    .quad 0x03FDB323A3A63594A  # 0.424940640468 542
+    .quad 0x03FDB323A3A63594A
+    .quad 0x03FDB3B68329C59E9  # 0.425500916886 543
+    .quad 0x03FDB3B68329C59E9
+    .quad 0x03FDB44977C148F1A  # 0.426061507389 544
+    .quad 0x03FDB44977C148F1A
+    .quad 0x03FDB50D895F7773A  # 0.426809450580 545
+    .quad 0x03FDB50D895F7773A
+    .quad 0x03FDB5A0AF3D169CD  # 0.427370775322 546
+    .quad 0x03FDB5A0AF3D169CD
+    .quad 0x03FDB66502A41E541  # 0.428119698779 547
+    .quad 0x03FDB66502A41E541
+    .quad 0x03FDB6F859E8EF639  # 0.428681759684 548
+    .quad 0x03FDB6F859E8EF639
+    .quad 0x03FDB78BC664238C0  # 0.429244136679 549
+    .quad 0x03FDB78BC664238C0
+    .quad 0x03FDB85078123E586  # 0.429994464983 550
+    .quad 0x03FDB85078123E586
+    .quad 0x03FDB8E41624226C5  # 0.430557580905 551
+    .quad 0x03FDB8E41624226C5
+    .quad 0x03FDB9A90A06BCB3D  # 0.431308895742 552
+    .quad 0x03FDB9A90A06BCB3D
+    .quad 0x03FDBA3CD9D0B81BD  # 0.431872752537 553
+    .quad 0x03FDBA3CD9D0B81BD
+    .quad 0x03FDBAD0BEF3DB164  # 0.432436927446 554
+    .quad 0x03FDBAD0BEF3DB164
+    .quad 0x03FDBB9611B80E2FC  # 0.433189656123 555
+    .quad 0x03FDBB9611B80E2FC
+    .quad 0x03FDBC2A28C33B75D  # 0.433754574696 556
+    .quad 0x03FDBC2A28C33B75D
+    .quad 0x03FDBCBE553C2BDDF  # 0.434319812582 557
+    .quad 0x03FDBCBE553C2BDDF
+    .quad 0x03FDBD84073D8EC2B  # 0.435073960430 558
+    .quad 0x03FDBD84073D8EC2B
+    .quad 0x03FDBE1865CEC1EC9  # 0.435639944787 559
+    .quad 0x03FDBE1865CEC1EC9
+    .quad 0x03FDBEACD9E271AD1  # 0.436206249662 560
+    .quad 0x03FDBEACD9E271AD1
+    .quad 0x03FDBF72EB7D20355  # 0.436961822044 561
+    .quad 0x03FDBF72EB7D20355
+    .quad 0x03FDC00791D99132B  # 0.437528876213 562
+    .quad 0x03FDC00791D99132B
+    .quad 0x03FDC09C4DCD565AB  # 0.438096252115 563
+    .quad 0x03FDC09C4DCD565AB
+    .quad 0x03FDC162BF5DF23E4  # 0.438853254422 564
+    .quad 0x03FDC162BF5DF23E4
+    .quad 0x03FDC1F7ADCB3DAB0  # 0.439421382456 565
+    .quad 0x03FDC1F7ADCB3DAB0
+    .quad 0x03FDC28CB1E4D32FD  # 0.439989833442 566
+    .quad 0x03FDC28CB1E4D32FD
+    .quad 0x03FDC35383C8850B0  # 0.440748271097 567
+    .quad 0x03FDC35383C8850B0
+    .quad 0x03FDC3E8BA8CACF27  # 0.441317477070 568
+    .quad 0x03FDC3E8BA8CACF27
+    .quad 0x03FDC47E071233744  # 0.441887007223 569
+    .quad 0x03FDC47E071233744
+    .quad 0x03FDC54539A6ABCD2  # 0.442646885679 570
+    .quad 0x03FDC54539A6ABCD2
+    .quad 0x03FDC5DAB908186FF  # 0.443217173690 571
+    .quad 0x03FDC5DAB908186FF
+    .quad 0x03FDC6704E4016FF7  # 0.443787787115 572
+    .quad 0x03FDC6704E4016FF7
+    .quad 0x03FDC737E1E38F4FB  # 0.444549111857 573
+    .quad 0x03FDC737E1E38F4FB
+    .quad 0x03FDC7CDAA290FEAD  # 0.445120486027 574
+    .quad 0x03FDC7CDAA290FEAD
+    .quad 0x03FDC863885A74D16  # 0.445692186852 575
+    .quad 0x03FDC863885A74D16
+    .quad 0x03FDC8F97C7E299DB  # 0.446264214707 576
+    .quad 0x03FDC8F97C7E299DB
+    .quad 0x03FDC9C18EDC7C26B  # 0.447027427871 577
+    .quad 0x03FDC9C18EDC7C26B
+    .quad 0x03FDCA57B64E9DB05  # 0.447600220249 578
+    .quad 0x03FDCA57B64E9DB05
+    .quad 0x03FDCAEDF3C88A364  # 0.448173340907 579
+    .quad 0x03FDCAEDF3C88A364
+    .quad 0x03FDCB844750B9995  # 0.448746790220 580
+    .quad 0x03FDCB844750B9995
+    .quad 0x03FDCC4CD90B3ECE5  # 0.449511901199 581
+    .quad 0x03FDCC4CD90B3ECE5
+    .quad 0x03FDCCE3602341C10  # 0.450086118843 582
+    .quad 0x03FDCCE3602341C10
+    .quad 0x03FDCD79FD5F2BC77  # 0.450660666403 583
+    .quad 0x03FDCD79FD5F2BC77
+    .quad 0x03FDCE10B0C581284  # 0.451235544257 584
+    .quad 0x03FDCE10B0C581284
+    .quad 0x03FDCED9C27EC6607  # 0.452002562511 585
+    .quad 0x03FDCED9C27EC6607
+    .quad 0x03FDCF70A9B6D3810  # 0.452578212532 586
+    .quad 0x03FDCF70A9B6D3810
+    .quad 0x03FDD007A72F19BBC  # 0.453154194116 587
+    .quad 0x03FDD007A72F19BBC
+    .quad 0x03FDD09EBAEE29DD8  # 0.453730507647 588
+    .quad 0x03FDD09EBAEE29DD8
+    .quad 0x03FDD1684D49F46AE  # 0.454499442710 589
+    .quad 0x03FDD1684D49F46AE
+    .quad 0x03FDD1FF951D1F1B3  # 0.455076532271 590
+    .quad 0x03FDD1FF951D1F1B3
+    .quad 0x03FDD296F34D0B65C  # 0.455653955057 591
+    .quad 0x03FDD296F34D0B65C
+    .quad 0x03FDD32E67E056BD5  # 0.456231711452 592
+    .quad 0x03FDD32E67E056BD5
+    .quad 0x03FDD3C5F2DDA1840  # 0.456809801843 593
+    .quad 0x03FDD3C5F2DDA1840
+    .quad 0x03FDD490246DEFA6A  # 0.457581109247 594
+    .quad 0x03FDD490246DEFA6A
+    .quad 0x03FDD527E3D1B95FC  # 0.458159980465 595
+    .quad 0x03FDD527E3D1B95FC
+    .quad 0x03FDD5BFB9B5AE71F  # 0.458739186968 596
+    .quad 0x03FDD5BFB9B5AE71F
+    .quad 0x03FDD657A6207C0DB  # 0.459318729146 597
+    .quad 0x03FDD657A6207C0DB
+    .quad 0x03FDD6EFA918D25CE  # 0.459898607388 598
+    .quad 0x03FDD6EFA918D25CE
+    .quad 0x03FDD7BA7AD9E7DA1  # 0.460672301817 599
+    .quad 0x03FDD7BA7AD9E7DA1
+    .quad 0x03FDD852B28BE5A0F  # 0.461252965726 600
+    .quad 0x03FDD852B28BE5A0F
+    .quad 0x03FDD8EB00E1CCE14  # 0.461833967001 601
+    .quad 0x03FDD8EB00E1CCE14
+    .quad 0x03FDD98365E25ABB9  # 0.462415306035 602
+    .quad 0x03FDD98365E25ABB9
+    .quad 0x03FDDA1BE1944F538  # 0.462996983220 603
+    .quad 0x03FDDA1BE1944F538
+    .quad 0x03FDDAE75484C9615  # 0.463773079495 604
+    .quad 0x03FDDAE75484C9615
+    .quad 0x03FDDB8005445488B  # 0.464355547233 605
+    .quad 0x03FDDB8005445488B
+    .quad 0x03FDDC18CCCBDCB83  # 0.464938354438 606
+    .quad 0x03FDDC18CCCBDCB83
+    .quad 0x03FDDCB1AB222F33D  # 0.465521501504 607
+    .quad 0x03FDDCB1AB222F33D
+    .quad 0x03FDDD4AA04E1C4B7  # 0.466104988830 608
+    .quad 0x03FDDD4AA04E1C4B7
+    .quad 0x03FDDDE3AC56775D2  # 0.466688816812 609
+    .quad 0x03FDDDE3AC56775D2
+    .quad 0x03FDDE7CCF4216D6E  # 0.467272985848 610
+    .quad 0x03FDDE7CCF4216D6E
+    .quad 0x03FDDF492177D7BBC  # 0.468052409114 611
+    .quad 0x03FDDF492177D7BBC
+    .quad 0x03FDDFE279E5BF4EE  # 0.468637375496 612
+    .quad 0x03FDDFE279E5BF4EE
+    .quad 0x03FDE07BE94DCC439  # 0.469222684263 613
+    .quad 0x03FDE07BE94DCC439
+    .quad 0x03FDE1156FB6E2626  # 0.469808335817 614
+    .quad 0x03FDE1156FB6E2626
+    .quad 0x03FDE1AF0D27E88D7  # 0.470394330560 615
+    .quad 0x03FDE1AF0D27E88D7
+    .quad 0x03FDE248C1A7C8C26  # 0.470980668894 616
+    .quad 0x03FDE248C1A7C8C26
+    .quad 0x03FDE2E28D3D701CC  # 0.471567351222 617
+    .quad 0x03FDE2E28D3D701CC
+    .quad 0x03FDE37C6FEFCED73  # 0.472154377948 618
+    .quad 0x03FDE37C6FEFCED73
+    .quad 0x03FDE449C232C39D8  # 0.472937616681 619
+    .quad 0x03FDE449C232C39D8
+    .quad 0x03FDE4E3DAEDDB5F6  # 0.473525448578 620
+    .quad 0x03FDE4E3DAEDDB5F6
+    .quad 0x03FDE57E0ADCE1EA5  # 0.474113626224 621
+    .quad 0x03FDE57E0ADCE1EA5
+    .quad 0x03FDE6185206D516F  # 0.474702150027 622
+    .quad 0x03FDE6185206D516F
+    .quad 0x03FDE6B2B072B5E6F  # 0.475291020395 623
+    .quad 0x03FDE6B2B072B5E6F
+    .quad 0x03FDE74D26278887A  # 0.475880237735 624
+    .quad 0x03FDE74D26278887A
+    .quad 0x03FDE7E7B32C5453F  # 0.476469802457 625
+    .quad 0x03FDE7E7B32C5453F
+    .quad 0x03FDE882578823D52  # 0.477059714970 626
+    .quad 0x03FDE882578823D52
+    .quad 0x03FDE91D134204C67  # 0.477649975686 627
+    .quad 0x03FDE91D134204C67
+    .quad 0x03FDE9B7E6610815A  # 0.478240585015 628
+    .quad 0x03FDE9B7E6610815A
+    .quad 0x03FDEA52D0EC41E5E  # 0.478831543369 629
+    .quad 0x03FDEA52D0EC41E5E
+    .quad 0x03FDEB218376ECFC0  # 0.479620031484 630
+    .quad 0x03FDEB218376ECFC0
+    .quad 0x03FDEBBCA4C4E9E87  # 0.480211805838 631
+    .quad 0x03FDEBBCA4C4E9E87
+    .quad 0x03FDEC57DD96CD0CB  # 0.480803930597 632
+    .quad 0x03FDEC57DD96CD0CB
+    .quad 0x03FDECF32DF3B887D  # 0.481396406174 633
+    .quad 0x03FDECF32DF3B887D
+    .quad 0x03FDED8E95E2D1B88  # 0.481989232987 634
+    .quad 0x03FDED8E95E2D1B88
+    .quad 0x03FDEE2A156B413E5  # 0.482582411453 635
+    .quad 0x03FDEE2A156B413E5
+    .quad 0x03FDEEC5AC9432FCB  # 0.483175941987 636
+    .quad 0x03FDEEC5AC9432FCB
+    .quad 0x03FDEF615B64D61C7  # 0.483769825010 637
+    .quad 0x03FDEF615B64D61C7
+    .quad 0x03FDEFFD21E45D0D1  # 0.484364060939 638
+    .quad 0x03FDEFFD21E45D0D1
+    .quad 0x03FDF0990019FD887  # 0.484958650194 639
+    .quad 0x03FDF0990019FD887
+    .quad 0x03FDF134F60CF092D  # 0.485553593197 640
+    .quad 0x03FDF134F60CF092D
+    .quad 0x03FDF1D103C4727E4  # 0.486148890367 641
+    .quad 0x03FDF1D103C4727E4
+    .quad 0x03FDF26D2947C2EC5  # 0.486744542127 642
+    .quad 0x03FDF26D2947C2EC5
+    .quad 0x03FDF309669E24CF9  # 0.487340548899 643
+    .quad 0x03FDF309669E24CF9
+    .quad 0x03FDF3A5BBCEDE6E1  # 0.487936911107 644
+    .quad 0x03FDF3A5BBCEDE6E1
+    .quad 0x03FDF44228E13963A  # 0.488533629176 645
+    .quad 0x03FDF44228E13963A
+    .quad 0x03FDF4DEADDC82A35  # 0.489130703529 646
+    .quad 0x03FDF4DEADDC82A35
+    .quad 0x03FDF57B4AC80A79A  # 0.489728134594 647
+    .quad 0x03FDF57B4AC80A79A
+    .quad 0x03FDF617FFAB248ED  # 0.490325922795 648
+    .quad 0x03FDF617FFAB248ED
+    .quad 0x03FDF6B4CC8D27E87  # 0.490924068561 649
+    .quad 0x03FDF6B4CC8D27E87
+    .quad 0x03FDF751B1756EEC8  # 0.491522572320 650
+    .quad 0x03FDF751B1756EEC8
+    .quad 0x03FDF7EEAE6B5761C  # 0.492121434499 651
+    .quad 0x03FDF7EEAE6B5761C
+    .quad 0x03FDF88BC3764273B  # 0.492720655530 652
+    .quad 0x03FDF88BC3764273B
+    .quad 0x03FDF928F09D94B32  # 0.493320235842 653
+    .quad 0x03FDF928F09D94B32
+    .quad 0x03FDF9C635E8B6192  # 0.493920175866 654
+    .quad 0x03FDF9C635E8B6192
+    .quad 0x03FDFA63935F1208C  # 0.494520476034 655
+    .quad 0x03FDFA63935F1208C
+    .quad 0x03FDFB0109081751A  # 0.495121136779 656
+    .quad 0x03FDFB0109081751A
+    .quad 0x03FDFB9E96EB38311  # 0.495722158534 657
+    .quad 0x03FDFB9E96EB38311
+    .quad 0x03FDFC3C3D0FEA555  # 0.496323541733 658
+    .quad 0x03FDFC3C3D0FEA555
+    .quad 0x03FDFCD9FB7DA6DEF  # 0.496925286812 659
+    .quad 0x03FDFCD9FB7DA6DEF
+    .quad 0x03FDFD77D23BEA634  # 0.497527394206 660
+    .quad 0x03FDFD77D23BEA634
+    .quad 0x03FDFE15C15234EE2  # 0.498129864352 661
+    .quad 0x03FDFE15C15234EE2
+    .quad 0x03FDFEB3C8C80A04E  # 0.498732697687 662
+    .quad 0x03FDFEB3C8C80A04E
+    .quad 0x03FDFF51E8A4F0A74  # 0.499335894649 663
+    .quad 0x03FDFF51E8A4F0A74
+    .quad 0x03FDFFF020F07352E  # 0.499939455677 664
+    .quad 0x03FDFFF020F07352E
+    .quad 0x03FE004738D910023  # 0.500543381211 665
+    .quad 0x03FE004738D910023
+    .quad 0x03FE00966D78C41CF  # 0.501147671692 666
+    .quad 0x03FE00966D78C41CF
+    .quad 0x03FE00E5AE5B207AB  # 0.501752327560 667
+    .quad 0x03FE00E5AE5B207AB
+    .quad 0x03FE011A8B18F0ED6  # 0.502155634684 668
+    .quad 0x03FE011A8B18F0ED6
+    .quad 0x03FE0169E072D7311  # 0.502760900515 669
+    .quad 0x03FE0169E072D7311
+    .quad 0x03FE01B942198A5A1  # 0.503366532915 670
+    .quad 0x03FE01B942198A5A1
+    .quad 0x03FE0208B010DB642  # 0.503972532327 671
+    .quad 0x03FE0208B010DB642
+    .quad 0x03FE02582A5C9D122  # 0.504578899198 672
+    .quad 0x03FE02582A5C9D122
+    .quad 0x03FE02A7B100A3EF0  # 0.505185633972 673
+    .quad 0x03FE02A7B100A3EF0
+    .quad 0x03FE02F74400C64EA  # 0.505792737097 674
+    .quad 0x03FE02F74400C64EA
+    .quad 0x03FE0346E360DC4F9  # 0.506400209020 675
+    .quad 0x03FE0346E360DC4F9
+    .quad 0x03FE03968F24BFDB6  # 0.507008050190 676
+    .quad 0x03FE03968F24BFDB6
+    .quad 0x03FE03E647504CA89  # 0.507616261055 677
+    .quad 0x03FE03E647504CA89
+    .quad 0x03FE04360BE7603AE  # 0.508224842066 678
+    .quad 0x03FE04360BE7603AE
+    .quad 0x03FE046B4089BE0FD  # 0.508630768599 679
+    .quad 0x03FE046B4089BE0FD
+    .quad 0x03FE04BB19DCA36B3  # 0.509239967521 680
+    .quad 0x03FE04BB19DCA36B3
+    .quad 0x03FE050AFFA5671A5  # 0.509849537793 681
+    .quad 0x03FE050AFFA5671A5
+    .quad 0x03FE055AF1E7ED47B  # 0.510459479867 682
+    .quad 0x03FE055AF1E7ED47B
+    .quad 0x03FE05AAF0A81BF04  # 0.511069794198 683
+    .quad 0x03FE05AAF0A81BF04
+    .quad 0x03FE05FAFBE9DAE58  # 0.511680481240 684
+    .quad 0x03FE05FAFBE9DAE58
+    .quad 0x03FE064B13B113CDD  # 0.512291541448 685
+    .quad 0x03FE064B13B113CDD
+    .quad 0x03FE069B3801B2263  # 0.512902975280 686
+    .quad 0x03FE069B3801B2263
+    .quad 0x03FE06D0AC85B63A2  # 0.513310805628 687
+    .quad 0x03FE06D0AC85B63A2
+    .quad 0x03FE0720E5C40DF1D  # 0.513922863181 688
+    .quad 0x03FE0720E5C40DF1D
+    .quad 0x03FE07712B9648153  # 0.514535295577 689
+    .quad 0x03FE07712B9648153
+    .quad 0x03FE07C17E0056E7C  # 0.515148103277 690
+    .quad 0x03FE07C17E0056E7C
+    .quad 0x03FE0811DD062E889  # 0.515761286740 691
+    .quad 0x03FE0811DD062E889
+    .quad 0x03FE086248ABC4F3B  # 0.516374846428 692
+    .quad 0x03FE086248ABC4F3B
+    .quad 0x03FE08B2C0F512033  # 0.516988782802 693
+    .quad 0x03FE08B2C0F512033
+    .quad 0x03FE08E86D82DA3EE  # 0.517398283218 694
+    .quad 0x03FE08E86D82DA3EE
+    .quad 0x03FE0938FAE5D8E9B  # 0.518012848432 695
+    .quad 0x03FE0938FAE5D8E9B
+    .quad 0x03FE098994F72C539  # 0.518627791569 696
+    .quad 0x03FE098994F72C539
+    .quad 0x03FE09DA3BBAD339C  # 0.519243113094 697
+    .quad 0x03FE09DA3BBAD339C
+    .quad 0x03FE0A2AEF34CE3D1  # 0.519858813473 698
+    .quad 0x03FE0A2AEF34CE3D1
+    .quad 0x03FE0A7BAF691FE34  # 0.520474893172 699
+    .quad 0x03FE0A7BAF691FE34
+    .quad 0x03FE0AB18BF5823C3  # 0.520885823936 700
+    .quad 0x03FE0AB18BF5823C3
+    .quad 0x03FE0B02616952989  # 0.521502536876 701
+    .quad 0x03FE0B02616952989
+    .quad 0x03FE0B5343A234476  # 0.522119630385 702
+    .quad 0x03FE0B5343A234476
+    .quad 0x03FE0BA432A430CA2  # 0.522737104934 703
+    .quad 0x03FE0BA432A430CA2
+    .quad 0x03FE0BF52E73538CE  # 0.523354960993 704
+    .quad 0x03FE0BF52E73538CE
+    .quad 0x03FE0C463713A9E6F  # 0.523973199034 705
+    .quad 0x03FE0C463713A9E6F
+    .quad 0x03FE0C7C43F4C861E  # 0.524385570174 706
+    .quad 0x03FE0C7C43F4C861E
+    .quad 0x03FE0CCD61FAD07D2  # 0.525004445903 707
+    .quad 0x03FE0CCD61FAD07D2
+    .quad 0x03FE0D1E8CDCE3DB6  # 0.525623704876 708
+    .quad 0x03FE0D1E8CDCE3DB6
+    .quad 0x03FE0D6FC49F16E93  # 0.526243347569 709
+    .quad 0x03FE0D6FC49F16E93
+    .quad 0x03FE0DC109458004A  # 0.526863374456 710
+    .quad 0x03FE0DC109458004A
+    .quad 0x03FE0DF73E353F0ED  # 0.527276939392 711
+    .quad 0x03FE0DF73E353F0ED
+    .quad 0x03FE0E4898611CCE1  # 0.527897607665 712
+    .quad 0x03FE0E4898611CCE1
+    .quad 0x03FE0E99FF7C20738  # 0.528518661406 713
+    .quad 0x03FE0E99FF7C20738
+    .quad 0x03FE0EEB738A67874  # 0.529140101094 714
+    .quad 0x03FE0EEB738A67874
+    .quad 0x03FE0F21C81D1ADC3  # 0.529554608872 715
+    .quad 0x03FE0F21C81D1ADC3
+    .quad 0x03FE0F7351C9FCD7F  # 0.530176692874 716
+    .quad 0x03FE0F7351C9FCD7F
+    .quad 0x03FE0FC4E875254C1  # 0.530799164104 717
+    .quad 0x03FE0FC4E875254C1
+    .quad 0x03FE10168C22B8FB9  # 0.531422023047 718
+    .quad 0x03FE10168C22B8FB9
+    .quad 0x03FE10683CD6DEA54  # 0.532045270185 719
+    .quad 0x03FE10683CD6DEA54
+    .quad 0x03FE109EB9E2E4C97  # 0.532460984179 720
+    .quad 0x03FE109EB9E2E4C97
+    .quad 0x03FE10F08055E7785  # 0.533084879385 721
+    .quad 0x03FE10F08055E7785
+    .quad 0x03FE114253DA97DA0  # 0.533709164079 722
+    .quad 0x03FE114253DA97DA0
+    .quad 0x03FE1194347523FDC  # 0.534333838748 723
+    .quad 0x03FE1194347523FDC
+    .quad 0x03FE11CAD1789B0F8  # 0.534750505421 724
+    .quad 0x03FE11CAD1789B0F8
+    .quad 0x03FE121CC7EB8F7E6  # 0.535375831132 725
+    .quad 0x03FE121CC7EB8F7E6
+    .quad 0x03FE126ECB7F8F007  # 0.536001548120 726
+    .quad 0x03FE126ECB7F8F007
+    .quad 0x03FE12A57FDA37091  # 0.536418910396 727
+    .quad 0x03FE12A57FDA37091
+    .quad 0x03FE12F799594EFBC  # 0.537045280601 728
+    .quad 0x03FE12F799594EFBC
+    .quad 0x03FE1349C004AFB00  # 0.537672043392 729
+    .quad 0x03FE1349C004AFB00
+    .quad 0x03FE139BF3E094003  # 0.538299199261 730
+    .quad 0x03FE139BF3E094003
+    .quad 0x03FE13D2C873C5E13  # 0.538717521794 731
+    .quad 0x03FE13D2C873C5E13
+    .quad 0x03FE142512549C16C  # 0.539345333889 732
+    .quad 0x03FE142512549C16C
+    .quad 0x03FE14776971477F1  # 0.539973540381 733
+    .quad 0x03FE14776971477F1
+    .quad 0x03FE14C9CDCE0A74D  # 0.540602141763 734
+    .quad 0x03FE14C9CDCE0A74D
+    .quad 0x03FE1500C2BFD1561  # 0.541021428981 735
+    .quad 0x03FE1500C2BFD1561
+    .quad 0x03FE15533D3B8D7B3  # 0.541650689621 736
+    .quad 0x03FE15533D3B8D7B3
+    .quad 0x03FE15A5C502C6DC5  # 0.542280346478 737
+    .quad 0x03FE15A5C502C6DC5
+    .quad 0x03FE15DCD1973457B  # 0.542700338085 738
+    .quad 0x03FE15DCD1973457B
+    .quad 0x03FE162F6F9071F76  # 0.543330656416 739
+    .quad 0x03FE162F6F9071F76
+    .quad 0x03FE16821AE0A13C6  # 0.543961372300 740
+    .quad 0x03FE16821AE0A13C6
+    .quad 0x03FE16B93F2C12808  # 0.544382070665 741
+    .quad 0x03FE16B93F2C12808
+    .quad 0x03FE170C00C169B51  # 0.545013450251 742
+    .quad 0x03FE170C00C169B51
+    .quad 0x03FE175ECFB935CC6  # 0.545645228728 743
+    .quad 0x03FE175ECFB935CC6
+    .quad 0x03FE17B1AC17CBD5B  # 0.546277406602 744
+    .quad 0x03FE17B1AC17CBD5B
+    .quad 0x03FE17E8F12052E8A  # 0.546699080654 745
+    .quad 0x03FE17E8F12052E8A
+    .quad 0x03FE183BE3DE8A7AF  # 0.547331925312 746
+    .quad 0x03FE183BE3DE8A7AF
+    .quad 0x03FE188EE40F23CA7  # 0.547965170715 747
+    .quad 0x03FE188EE40F23CA7
+    .quad 0x03FE18C640FF75F06  # 0.548387557205 748
+    .quad 0x03FE18C640FF75F06
+    .quad 0x03FE191957A30FA51  # 0.549021471648 749
+    .quad 0x03FE191957A30FA51
+    .quad 0x03FE196C7BC4B1F3A  # 0.549655788193 750
+    .quad 0x03FE196C7BC4B1F3A
+    .quad 0x03FE19A3F0B1860BD  # 0.550078889532 751
+    .quad 0x03FE19A3F0B1860BD
+    .quad 0x03FE19F72B59A0CEC  # 0.550713877383 752
+    .quad 0x03FE19F72B59A0CEC
+    .quad 0x03FE1A4A738B7A33C  # 0.551349268700 753
+    .quad 0x03FE1A4A738B7A33C
+    .quad 0x03FE1A820089A2156  # 0.551773087312 754
+    .quad 0x03FE1A820089A2156
+    .quad 0x03FE1AD55F55855C8  # 0.552409152212 755
+    .quad 0x03FE1AD55F55855C8
+    .quad 0x03FE1B28CBB6EC93E  # 0.553045621948 756
+    .quad 0x03FE1B28CBB6EC93E
+    .quad 0x03FE1B6070DB553D8  # 0.553470160269 757
+    .quad 0x03FE1B6070DB553D8
+    .quad 0x03FE1BB3F3EA714F6  # 0.554107305878 758
+    .quad 0x03FE1BB3F3EA714F6
+    .quad 0x03FE1BEBA8316EF2C  # 0.554532295260 759
+    .quad 0x03FE1BEBA8316EF2C
+    .quad 0x03FE1C3F41FA97C6B  # 0.555170118179 760
+    .quad 0x03FE1C3F41FA97C6B
+    .quad 0x03FE1C92E96C86020  # 0.555808348176 761
+    .quad 0x03FE1C92E96C86020
+    .quad 0x03FE1CCAB5FBFFEE1  # 0.556234061252 762
+    .quad 0x03FE1CCAB5FBFFEE1
+    .quad 0x03FE1D1E743BCFC47  # 0.556872970868 763
+    .quad 0x03FE1D1E743BCFC47
+    .quad 0x03FE1D72403052E75  # 0.557512288951 764
+    .quad 0x03FE1D72403052E75
+    .quad 0x03FE1DAA251D7E433  # 0.557938728190 765
+    .quad 0x03FE1DAA251D7E433
+    .quad 0x03FE1DFE07F3D1DAB  # 0.558578728212 766
+    .quad 0x03FE1DFE07F3D1DAB
+    .quad 0x03FE1E35FC265D75E  # 0.559005622562 767
+    .quad 0x03FE1E35FC265D75E
+    .quad 0x03FE1E89F5EB04126  # 0.559646305979 768
+    .quad 0x03FE1E89F5EB04126
+    .quad 0x03FE1EDDFD77E1FEF  # 0.560287400135 769
+    .quad 0x03FE1EDDFD77E1FEF
+    .quad 0x03FE1F160A2AD0DA3  # 0.560715024687 770
+    .quad 0x03FE1F160A2AD0DA3
+    .quad 0x03FE1F6A28BA1B476  # 0.561356804579 771
+    .quad 0x03FE1F6A28BA1B476
+    .quad 0x03FE1FBE551DB43C1  # 0.561998996616 772
+    .quad 0x03FE1FBE551DB43C1
+    .quad 0x03FE1FF67A6684F47  # 0.562427353873 773
+    .quad 0x03FE1FF67A6684F47
+    .quad 0x03FE204ABDE0BE5DF  # 0.563070233998 774
+    .quad 0x03FE204ABDE0BE5DF
+    .quad 0x03FE2082F29233211  # 0.563499050471 775
+    .quad 0x03FE2082F29233211
+    .quad 0x03FE20D74D2FBAFE4  # 0.564142620160 776
+    .quad 0x03FE20D74D2FBAFE4
+    .quad 0x03FE210F91524B469  # 0.564571896835 777
+    .quad 0x03FE210F91524B469
+    .quad 0x03FE2164031FDA0B0  # 0.565216157568 778
+    .quad 0x03FE2164031FDA0B0
+    .quad 0x03FE21B882DD26040  # 0.565860833641 779
+    .quad 0x03FE21B882DD26040
+    .quad 0x03FE21F0DFC65CEEC  # 0.566290848698 780
+    .quad 0x03FE21F0DFC65CEEC
+    .quad 0x03FE224576C81FFE0  # 0.566936218194 781
+    .quad 0x03FE224576C81FFE0
+    .quad 0x03FE227DE33896A44  # 0.567366696031 782
+    .quad 0x03FE227DE33896A44
+    .quad 0x03FE22D2918BA4A31  # 0.568012760445 783
+    .quad 0x03FE22D2918BA4A31
+    .quad 0x03FE23274DE272A83  # 0.568659242528 784
+    .quad 0x03FE23274DE272A83
+    .quad 0x03FE235FD33D232FC  # 0.569090462888 785
+    .quad 0x03FE235FD33D232FC
+    .quad 0x03FE23B4A6F9D8688  # 0.569737642287 786
+    .quad 0x03FE23B4A6F9D8688
+    .quad 0x03FE23ED3BF21CA33  # 0.570169328026 787
+    .quad 0x03FE23ED3BF21CA33
+    .quad 0x03FE24422721A89D7  # 0.570817206248 788
+    .quad 0x03FE24422721A89D7
+    .quad 0x03FE247ACBC023D2B  # 0.571249358372 789
+    .quad 0x03FE247ACBC023D2B
+    .quad 0x03FE24CFCE6F80D9B  # 0.571897936927 790
+    .quad 0x03FE24CFCE6F80D9B
+    .quad 0x03FE250882BCDD7D8  # 0.572330556445 791
+    .quad 0x03FE250882BCDD7D8
+    .quad 0x03FE255D9CF910A56  # 0.572979836849 792
+    .quad 0x03FE255D9CF910A56
+    .quad 0x03FE25B2C55CD5762  # 0.573629539091 793
+    .quad 0x03FE25B2C55CD5762
+    .quad 0x03FE25EB92D41992D  # 0.574062908546 794
+    .quad 0x03FE25EB92D41992D
+    .quad 0x03FE2640D2D99FFEA  # 0.574713315073 795
+    .quad 0x03FE2640D2D99FFEA
+    .quad 0x03FE2679B0166F51C  # 0.575147154559 796
+    .quad 0x03FE2679B0166F51C
+    .quad 0x03FE26CF07CAD8B00  # 0.575798266899 797
+    .quad 0x03FE26CF07CAD8B00
+    .quad 0x03FE2707F4D5F7C40  # 0.576232577438 798
+    .quad 0x03FE2707F4D5F7C40
+    .quad 0x03FE275D644670606  # 0.576884397124 799
+    .quad 0x03FE275D644670606
+    .quad 0x03FE27966128AB11B  # 0.577319179739 800
+    .quad 0x03FE27966128AB11B
+    .quad 0x03FE27EBE8626A387  # 0.577971708311 801
+    .quad 0x03FE27EBE8626A387
+    .quad 0x03FE2824F52493BD2  # 0.578406964030 802
+    .quad 0x03FE2824F52493BD2
+    .quad 0x03FE287A9434DBC7B  # 0.579060203030 803
+    .quad 0x03FE287A9434DBC7B
+    .quad 0x03FE28B3B0DFCEB80  # 0.579495932884 804
+    .quad 0x03FE28B3B0DFCEB80
+    .quad 0x03FE290967D3ED18D  # 0.580149883861 805
+    .quad 0x03FE290967D3ED18D
+    .quad 0x03FE294294708B773  # 0.580586088885 806
+    .quad 0x03FE294294708B773
+    .quad 0x03FE29986355D8C69  # 0.581240753393 807
+    .quad 0x03FE29986355D8C69
+    .quad 0x03FE29D19FED0C082  # 0.581677434622 808
+    .quad 0x03FE29D19FED0C082
+    .quad 0x03FE2A2786D0EC107  # 0.582332814220 809
+    .quad 0x03FE2A2786D0EC107
+    .quad 0x03FE2A60D36BA5253  # 0.582769972697 810
+    .quad 0x03FE2A60D36BA5253
+    .quad 0x03FE2AB6D25B86EF7  # 0.583426068948 811
+    .quad 0x03FE2AB6D25B86EF7
+    .quad 0x03FE2AF02F02BE4AB  # 0.583863705716 812
+    .quad 0x03FE2AF02F02BE4AB
+    .quad 0x03FE2B46460C1C2B3  # 0.584520520190 813
+    .quad 0x03FE2B46460C1C2B3
+    .quad 0x03FE2B7FB2C8D1CC1  # 0.584958636297 814
+    .quad 0x03FE2B7FB2C8D1CC1
+    .quad 0x03FE2BD5E1F9316F2  # 0.585616170568 815
+    .quad 0x03FE2BD5E1F9316F2
+    .quad 0x03FE2C0F5ED46CE8D  # 0.586054767066 816
+    .quad 0x03FE2C0F5ED46CE8D
+    .quad 0x03FE2C65A6395F5F5  # 0.586713022712 817
+    .quad 0x03FE2C65A6395F5F5
+    .quad 0x03FE2C9F333C2FE1E  # 0.587152100656 818
+    .quad 0x03FE2C9F333C2FE1E
+    .quad 0x03FE2CF592E351AE5  # 0.587811079263 819
+    .quad 0x03FE2CF592E351AE5
+    .quad 0x03FE2D2F3016CE0EF  # 0.588250639709 820
+    .quad 0x03FE2D2F3016CE0EF
+    .quad 0x03FE2D85A80DC7324  # 0.588910342867 821
+    .quad 0x03FE2D85A80DC7324
+    .quad 0x03FE2DBF557B0DF43  # 0.589350386878 822
+    .quad 0x03FE2DBF557B0DF43
+    .quad 0x03FE2E15E5CF91FA7  # 0.590010816181 823
+    .quad 0x03FE2E15E5CF91FA7
+    .quad 0x03FE2E4FA37FC9577  # 0.590451344823 824
+    .quad 0x03FE2E4FA37FC9577
+    .quad 0x03FE2E8967B3BF4E1  # 0.590892067615 825
+    .quad 0x03FE2E8967B3BF4E1
+    .quad 0x03FE2EE01A3BED567  # 0.591553516212 826
+    .quad 0x03FE2EE01A3BED567
+    .quad 0x03FE2F19EEBFB00BA  # 0.591994725131 827
+    .quad 0x03FE2F19EEBFB00BA
+    .quad 0x03FE2F70B9C67A7C2  # 0.592656903723 828
+    .quad 0x03FE2F70B9C67A7C2
+    .quad 0x03FE2FAA9EA342D04  # 0.593098599843 829
+    .quad 0x03FE2FAA9EA342D04
+    .quad 0x03FE3001823684D73  # 0.593761510043 830
+    .quad 0x03FE3001823684D73
+    .quad 0x03FE303B7775937EF  # 0.594203694441 831
+    .quad 0x03FE303B7775937EF
+    .quad 0x03FE309273A3340FC  # 0.594867337868 832
+    .quad 0x03FE309273A3340FC
+    .quad 0x03FE30CC794DD19D0  # 0.595310011625 833
+    .quad 0x03FE30CC794DD19D0
+    .quad 0x03FE3106858C76BB7  # 0.595752881428 834
+    .quad 0x03FE3106858C76BB7
+    .quad 0x03FE315DA4434068B  # 0.596417554101 835
+    .quad 0x03FE315DA4434068B
+    .quad 0x03FE3197C0FA80E6A  # 0.596860914783 836
+    .quad 0x03FE3197C0FA80E6A
+    .quad 0x03FE31EEF86D36EF1  # 0.597526324589 837
+    .quad 0x03FE31EEF86D36EF1
+    .quad 0x03FE322925A66E62D  # 0.597970177237 838
+    .quad 0x03FE322925A66E62D
+    .quad 0x03FE328075E32022F  # 0.598636325813 839
+    .quad 0x03FE328075E32022F
+    .quad 0x03FE32BAB3A7B21E9  # 0.599080671521 840
+    .quad 0x03FE32BAB3A7B21E9
+    .quad 0x03FE32F4F80D0B1BD  # 0.599525214760 841
+    .quad 0x03FE32F4F80D0B1BD
+    .quad 0x03FE334C6B15D30DD  # 0.600192400374 842
+    .quad 0x03FE334C6B15D30DD
+    .quad 0x03FE3386C013B90D6  # 0.600637438209 843
+    .quad 0x03FE3386C013B90D6
+    .quad 0x03FE33DE4C086C40A  # 0.601305366543 844
+    .quad 0x03FE33DE4C086C40A
+    .quad 0x03FE3418B1A85622C  # 0.601750900077 845
+    .quad 0x03FE3418B1A85622C
+    .quad 0x03FE34531DF21CFE3  # 0.602196632199 846
+    .quad 0x03FE34531DF21CFE3
+    .quad 0x03FE34AACCE299BA5  # 0.602865603124 847
+    .quad 0x03FE34AACCE299BA5
+    .quad 0x03FE34E549DBB21EF  # 0.603311832493 848
+    .quad 0x03FE34E549DBB21EF
+    .quad 0x03FE353D11DA4F855  # 0.603981550121 849
+    .quad 0x03FE353D11DA4F855
+    .quad 0x03FE35779F8C43D6D  # 0.604428277847 850
+    .quad 0x03FE35779F8C43D6D
+    .quad 0x03FE35B233F13DD4A  # 0.604875205229 851
+    .quad 0x03FE35B233F13DD4A
+    .quad 0x03FE360A1F1BBA738  # 0.605545971045 852
+    .quad 0x03FE360A1F1BBA738
+    .quad 0x03FE3644C446F97BC  # 0.605993398346 853
+    .quad 0x03FE3644C446F97BC
+    .quad 0x03FE367F702A9EA94  # 0.606441025927 854
+    .quad 0x03FE367F702A9EA94
+    .quad 0x03FE36D77E9D34FD7  # 0.607112843218 855
+    .quad 0x03FE36D77E9D34FD7
+    .quad 0x03FE37123B54987B7  # 0.607560972287 856
+    .quad 0x03FE37123B54987B7
+    .quad 0x03FE376A630C0A1D6  # 0.608233542652 857
+    .quad 0x03FE376A630C0A1D6
+    .quad 0x03FE37A530A0D5A31  # 0.608682174333 858
+    .quad 0x03FE37A530A0D5A31
+    .quad 0x03FE37E004F74E13B  # 0.609131007374 859
+    .quad 0x03FE37E004F74E13B
+    .quad 0x03FE383850278CFD9  # 0.609804634884 860
+    .quad 0x03FE383850278CFD9
+    .quad 0x03FE3873356902AB7  # 0.610253972119 861
+    .quad 0x03FE3873356902AB7
+    .quad 0x03FE38AE2171976E8  # 0.610703511349 862
+    .quad 0x03FE38AE2171976E8
+    .quad 0x03FE390690373AFFF  # 0.611378199331 863
+    .quad 0x03FE390690373AFFF
+    .quad 0x03FE39418D3872A53  # 0.611828244343 864
+    .quad 0x03FE39418D3872A53
+    .quad 0x03FE397C91064221F  # 0.612278491987 865
+    .quad 0x03FE397C91064221F
+    .quad 0x03FE39D5237E045A5  # 0.612954243787 866
+    .quad 0x03FE39D5237E045A5
+    .quad 0x03FE3A1038522CE82  # 0.613404998809 867
+    .quad 0x03FE3A1038522CE82
+    .quad 0x03FE3A68E45AD354B  # 0.614081512534 868
+    .quad 0x03FE3A68E45AD354B
+    .quad 0x03FE3AA40A3F2A68B  # 0.614532776080 869
+    .quad 0x03FE3AA40A3F2A68B
+    .quad 0x03FE3ADF36F98A182  # 0.614984243356 870
+    .quad 0x03FE3ADF36F98A182
+    .quad 0x03FE3B3806E5DF340  # 0.615661826668 871
+    .quad 0x03FE3B3806E5DF340
+    .quad 0x03FE3B7344BE40311  # 0.616113804077 872
+    .quad 0x03FE3B7344BE40311
+    .quad 0x03FE3BAE897234A87  # 0.616565985862 873
+    .quad 0x03FE3BAE897234A87
+    .quad 0x03FE3C077D5F51881  # 0.617244642149 874
+    .quad 0x03FE3C077D5F51881
+    .quad 0x03FE3C42D33F2AE7B  # 0.617697335683 875
+    .quad 0x03FE3C42D33F2AE7B
+    .quad 0x03FE3C7E30002960C  # 0.618150234241 876
+    .quad 0x03FE3C7E30002960C
+    .quad 0x03FE3CD7480B4A8A3  # 0.618829966906 877
+    .quad 0x03FE3CD7480B4A8A3
+    .quad 0x03FE3D12B60622748  # 0.619283378838 878
+    .quad 0x03FE3D12B60622748
+    .quad 0x03FE3D4E2AE7B7E2B  # 0.619736996447 879
+    .quad 0x03FE3D4E2AE7B7E2B
+    .quad 0x03FE3D89A6B1A558D  # 0.620190819917 880
+    .quad 0x03FE3D89A6B1A558D
+    .quad 0x03FE3DE2ED57B1F9B  # 0.620871941524 881
+    .quad 0x03FE3DE2ED57B1F9B
+    .quad 0x03FE3E1E7A6D8330E  # 0.621326280468 882
+    .quad 0x03FE3E1E7A6D8330E
+    .quad 0x03FE3E5A0E714DA6E  # 0.621780825931 883
+    .quad 0x03FE3E5A0E714DA6E
+    .quad 0x03FE3EB37978B85B6  # 0.622463031756 884
+    .quad 0x03FE3EB37978B85B6
+    .quad 0x03FE3EEF1ED68236B  # 0.622918094335 885
+    .quad 0x03FE3EEF1ED68236B
+    .quad 0x03FE3F2ACB27ED6C7  # 0.623373364090 886
+    .quad 0x03FE3F2ACB27ED6C7
+    .quad 0x03FE3F845AAE68C81  # 0.624056657591 887
+    .quad 0x03FE3F845AAE68C81
+    .quad 0x03FE3FC0186800514  # 0.624512446113 888
+    .quad 0x03FE3FC0186800514
+    .quad 0x03FE3FFBDD1AE8406  # 0.624968442473 889
+    .quad 0x03FE3FFBDD1AE8406
+    .quad 0x03FE4037A8C8C197A  # 0.625424646860 890
+    .quad 0x03FE4037A8C8C197A
+    .quad 0x03FE409167679DD99  # 0.626109343909 891
+    .quad 0x03FE409167679DD99
+    .quad 0x03FE40CD448FF6DD6  # 0.626566069196 892
+    .quad 0x03FE40CD448FF6DD6
+    .quad 0x03FE410928B8F950F  # 0.627023003177 893
+    .quad 0x03FE410928B8F950F
+    .quad 0x03FE41630C1B50AFF  # 0.627708795866 894
+    .quad 0x03FE41630C1B50AFF
+    .quad 0x03FE419F01CD27AD0  # 0.628166252416 895
+    .quad 0x03FE419F01CD27AD0
+    .quad 0x03FE41DAFE85672B9  # 0.628623918328 896
+    .quad 0x03FE41DAFE85672B9
+    .quad 0x03FE42170245B4C6A  # 0.629081793794 897
+    .quad 0x03FE42170245B4C6A
+    .quad 0x03FE42711518DF546  # 0.629769000326 898
+    .quad 0x03FE42711518DF546
+    .quad 0x03FE42AD2A74888A0  # 0.630227400518 899
+    .quad 0x03FE42AD2A74888A0
+    .quad 0x03FE42E946DE080C0  # 0.630686010936 900
+    .quad 0x03FE42E946DE080C0
+    .quad 0x03FE43437EB9D9424  # 0.631374321162 901
+    .quad 0x03FE43437EB9D9424
+    .quad 0x03FE437FACCD31C10  # 0.631833457993 902
+    .quad 0x03FE437FACCD31C10
+    .quad 0x03FE43BBE1F42FE09  # 0.632292805727 903
+    .quad 0x03FE43BBE1F42FE09
+    .quad 0x03FE43F81E307DE5E  # 0.632752364559 904
+    .quad 0x03FE43F81E307DE5E
+    .quad 0x03FE445285D68EA69  # 0.633442099038 905
+    .quad 0x03FE445285D68EA69
+    .quad 0x03FE448ED3CF71355  # 0.633902186463 906
+    .quad 0x03FE448ED3CF71355
+    .quad 0x03FE44CB28E37C3EE  # 0.634362485666 907
+    .quad 0x03FE44CB28E37C3EE
+    .quad 0x03FE450785145CAFE  # 0.634822996841 908
+    .quad 0x03FE450785145CAFE
+    .quad 0x03FE45621CB769366  # 0.635514161481 909
+    .quad 0x03FE45621CB769366
+    .quad 0x03FE459E8AB7B799D  # 0.635975203444 910
+    .quad 0x03FE459E8AB7B799D
+    .quad 0x03FE45DAFFDABD4DB  # 0.636436458065 911
+    .quad 0x03FE45DAFFDABD4DB
+    .quad 0x03FE46177C2229EC0  # 0.636897925539 912
+    .quad 0x03FE46177C2229EC0
+    .quad 0x03FE467243F53F69E  # 0.637590526283 913
+    .quad 0x03FE467243F53F69E
+    .quad 0x03FE46AED21F117FC  # 0.638052526753 914
+    .quad 0x03FE46AED21F117FC
+    .quad 0x03FE46EB677335D13  # 0.638514740766 915
+    .quad 0x03FE46EB677335D13
+    .quad 0x03FE472803F35EAAE  # 0.638977168520 916
+    .quad 0x03FE472803F35EAAE
+    .quad 0x03FE4764A7A13EF3B  # 0.639439810212 917
+    .quad 0x03FE4764A7A13EF3B
+    .quad 0x03FE47BFAA9F80271  # 0.640134174319 918
+    .quad 0x03FE47BFAA9F80271
+    .quad 0x03FE47FC60471DAF8  # 0.640597351724 919
+    .quad 0x03FE47FC60471DAF8
+    .quad 0x03FE48391D226992D  # 0.641060743762 920
+    .quad 0x03FE48391D226992D
+    .quad 0x03FE4875E1331971E  # 0.641524350631 921
+    .quad 0x03FE4875E1331971E
+    .quad 0x03FE48D114D3FB884  # 0.642220164181 922
+    .quad 0x03FE48D114D3FB884
+    .quad 0x03FE490DEAF1A3FC8  # 0.642684309003 923
+    .quad 0x03FE490DEAF1A3FC8
+    .quad 0x03FE494AC84AB0ED3  # 0.643148669355 924
+    .quad 0x03FE494AC84AB0ED3
+    .quad 0x03FE4987ACE0DABB0  # 0.643613245438 925
+    .quad 0x03FE4987ACE0DABB0
+    .quad 0x03FE49C498B5DA63F  # 0.644078037452 926
+    .quad 0x03FE49C498B5DA63F
+    .quad 0x03FE4A20080EF10B2  # 0.644775630783 927
+    .quad 0x03FE4A20080EF10B2
+    .quad 0x03FE4A5D060894B8C  # 0.645240963504 928
+    .quad 0x03FE4A5D060894B8C
+    .quad 0x03FE4A9A0B471A943  # 0.645706512861 929
+    .quad 0x03FE4A9A0B471A943
+    .quad 0x03FE4AD717CC3E626  # 0.646172279055 930
+    .quad 0x03FE4AD717CC3E626
+    .quad 0x03FE4B142B99BC871  # 0.646638262288 931
+    .quad 0x03FE4B142B99BC871
+    .quad 0x03FE4B6FD6F970C1F  # 0.647337644529 932
+    .quad 0x03FE4B6FD6F970C1F
+    .quad 0x03FE4BACFD036D080  # 0.647804171246 933
+    .quad 0x03FE4BACFD036D080
+    .quad 0x03FE4BEA2A5BDBE87  # 0.648270915712 934
+    .quad 0x03FE4BEA2A5BDBE87
+    .quad 0x03FE4C275F047C956  # 0.648737878130 935
+    .quad 0x03FE4C275F047C956
+    .quad 0x03FE4C649AFF0EE16  # 0.649205058703 936
+    .quad 0x03FE4C649AFF0EE16
+    .quad 0x03FE4CC082B46485A  # 0.649906239052 937
+    .quad 0x03FE4CC082B46485A
+    .quad 0x03FE4CFDD1037E37C  # 0.650373965908 938
+    .quad 0x03FE4CFDD1037E37C
+    .quad 0x03FE4D3B26AAADDD9  # 0.650841911635 939
+    .quad 0x03FE4D3B26AAADDD9
+    .quad 0x03FE4D7883ABB61F6  # 0.651310076438 940
+    .quad 0x03FE4D7883ABB61F6
+    .quad 0x03FE4DB5E8085A477  # 0.651778460521 941
+    .quad 0x03FE4DB5E8085A477
+    .quad 0x03FE4DF353C25E42B  # 0.652247064091 942
+    .quad 0x03FE4DF353C25E42B
+    .quad 0x03FE4E4F832C560DD  # 0.652950381434 943
+    .quad 0x03FE4E4F832C560DD
+    .quad 0x03FE4E8D015786F16  # 0.653419534621 944
+    .quad 0x03FE4E8D015786F16
+    .quad 0x03FE4ECA86E64A683  # 0.653888908016 945
+    .quad 0x03FE4ECA86E64A683
+    .quad 0x03FE4F0813DA673DD  # 0.654358501826 946
+    .quad 0x03FE4F0813DA673DD
+    .quad 0x03FE4F45A835A4E19  # 0.654828316258 947
+    .quad 0x03FE4F45A835A4E19
+    .quad 0x03FE4F8343F9CB678  # 0.655298351519 948
+    .quad 0x03FE4F8343F9CB678
+    .quad 0x03FE4FDFBB88A119A  # 0.656003818920 949
+    .quad 0x03FE4FDFBB88A119A
+    .quad 0x03FE501D69DADD660  # 0.656474407164 950
+    .quad 0x03FE501D69DADD660
+    .quad 0x03FE505B1F9C43ED7  # 0.656945216966 951
+    .quad 0x03FE505B1F9C43ED7
+    .quad 0x03FE5098DCCE9FABA  # 0.657416248534 952
+    .quad 0x03FE5098DCCE9FABA
+    .quad 0x03FE50D6A173BC425  # 0.657887502077 953
+    .quad 0x03FE50D6A173BC425
+    .quad 0x03FE51146D8D65F98  # 0.658358977805 954
+    .quad 0x03FE51146D8D65F98
+    .quad 0x03FE5152411D69C03  # 0.658830675927 955
+    .quad 0x03FE5152411D69C03
+    .quad 0x03FE51AF0C774A2D0  # 0.659538640558 956
+    .quad 0x03FE51AF0C774A2D0
+    .quad 0x03FE51ECF2B713F8A  # 0.660010895584 957
+    .quad 0x03FE51ECF2B713F8A
+    .quad 0x03FE522AE0738A3D8  # 0.660483373741 958
+    .quad 0x03FE522AE0738A3D8
+    .quad 0x03FE5268D5AE7CDCB  # 0.660956075239 959
+    .quad 0x03FE5268D5AE7CDCB
+    .quad 0x03FE52A6D269BC600  # 0.661429000289 960
+    .quad 0x03FE52A6D269BC600
+    .quad 0x03FE52E4D6A719F9B  # 0.661902149103 961
+    .quad 0x03FE52E4D6A719F9B
+    .quad 0x03FE5322E26867857  # 0.662375521893 962
+    .quad 0x03FE5322E26867857
+    .quad 0x03FE53800225BA6E2  # 0.663086001497 963
+    .quad 0x03FE53800225BA6E2
+    .quad 0x03FE53BE20B8DA502  # 0.663559935155 964
+    .quad 0x03FE53BE20B8DA502
+    .quad 0x03FE53FC46D64DDD1  # 0.664034093533 965
+    .quad 0x03FE53FC46D64DDD1
+    .quad 0x03FE543A747FE9ED6  # 0.664508476843 966
+    .quad 0x03FE543A747FE9ED6
+    .quad 0x03FE5478A9B78404C  # 0.664983085300 967
+    .quad 0x03FE5478A9B78404C
+    .quad 0x03FE54B6E67EF251C  # 0.665457919117 968
+    .quad 0x03FE54B6E67EF251C
+    .quad 0x03FE54F52AD80BAE9  # 0.665932978509 969
+    .quad 0x03FE54F52AD80BAE9
+    .quad 0x03FE553376C4A7A16  # 0.666408263689 970
+    .quad 0x03FE553376C4A7A16
+    .quad 0x03FE5571CA469E5C9  # 0.666883774872 971
+    .quad 0x03FE5571CA469E5C9
+    .quad 0x03FE55CF55C5A5437  # 0.667597465874 972
+    .quad 0x03FE55CF55C5A5437
+    .quad 0x03FE560DBC45153C7  # 0.668073543008 973
+    .quad 0x03FE560DBC45153C7
+    .quad 0x03FE564C2A6059FE7  # 0.668549846899 974
+    .quad 0x03FE564C2A6059FE7
+    .quad 0x03FE568AA0194EC6E  # 0.669026377763 975
+    .quad 0x03FE568AA0194EC6E
+    .quad 0x03FE56C91D71CF810  # 0.669503135817 976
+    .quad 0x03FE56C91D71CF810
+    .quad 0x03FE5707A26BB8C66  # 0.669980121278 977
+    .quad 0x03FE5707A26BB8C66
+    .quad 0x03FE57462F08E7DF5  # 0.670457334363 978
+    .quad 0x03FE57462F08E7DF5
+    .quad 0x03FE5784C34B3AC30  # 0.670934775289 979
+    .quad 0x03FE5784C34B3AC30
+    .quad 0x03FE57C35F3490183  # 0.671412444273 980
+    .quad 0x03FE57C35F3490183
+    .quad 0x03FE580202C6C7353  # 0.671890341535 981
+    .quad 0x03FE580202C6C7353
+    .quad 0x03FE5840AE03C0204  # 0.672368467291 982
+    .quad 0x03FE5840AE03C0204
+    .quad 0x03FE589EBD437CA31  # 0.673086084831 983
+    .quad 0x03FE589EBD437CA31
+    .quad 0x03FE58DD7BB392B30  # 0.673564782782 984
+    .quad 0x03FE58DD7BB392B30
+    .quad 0x03FE591C41D500163  # 0.674043709994 985
+    .quad 0x03FE591C41D500163
+    .quad 0x03FE595B0FA9A7EF1  # 0.674522866688 986
+    .quad 0x03FE595B0FA9A7EF1
+    .quad 0x03FE5999E5336E121  # 0.675002253082 987
+    .quad 0x03FE5999E5336E121
+    .quad 0x03FE59D8C2743705E  # 0.675481869398 988
+    .quad 0x03FE59D8C2743705E
+    .quad 0x03FE5A17A76DE803B  # 0.675961715857 989
+    .quad 0x03FE5A17A76DE803B
+    .quad 0x03FE5A56942266F7B  # 0.676441792678 990
+    .quad 0x03FE5A56942266F7B
+    .quad 0x03FE5A9588939A810  # 0.676922100084 991
+    .quad 0x03FE5A9588939A810
+    .quad 0x03FE5AD484C369F2D  # 0.677402638296 992
+    .quad 0x03FE5AD484C369F2D
+    .quad 0x03FE5B1388B3BD53E  # 0.677883407536 993
+    .quad 0x03FE5B1388B3BD53E
+    .quad 0x03FE5B5294667D5F7  # 0.678364408027 994
+    .quad 0x03FE5B5294667D5F7
+    .quad 0x03FE5B91A7DD93852  # 0.678845639990 995
+    .quad 0x03FE5B91A7DD93852
+    .quad 0x03FE5BD0C31AE9E9D  # 0.679327103649 996
+    .quad 0x03FE5BD0C31AE9E9D
+    .quad 0x03FE5C2F7A8ED5E5B  # 0.680049734055 997
+    .quad 0x03FE5C2F7A8ED5E5B
+    .quad 0x03FE5C6EA94431EF9  # 0.680531777930 998
+    .quad 0x03FE5C6EA94431EF9
+    .quad 0x03FE5CADDFC6874F5  # 0.681014054284 999
+    .quad 0x03FE5CADDFC6874F5
+    .quad 0x03FE5CED1E17C35C6  # 0.681496563340 1000
+    .quad 0x03FE5CED1E17C35C6
+    .quad 0x03FE5D2C6439D4252  # 0.681979305324 1001
+    .quad 0x03FE5D2C6439D4252
+    .quad 0x03FE5D6BB22EA86F6  # 0.682462280460 1002
+    .quad 0x03FE5D6BB22EA86F6
+    .quad 0x03FE5DAB07F82FB84  # 0.682945488974 1003
+    .quad 0x03FE5DAB07F82FB84
+    .quad 0x03FE5DEA65985A350  # 0.683428931091 1004
+    .quad 0x03FE5DEA65985A350
+    .quad 0x03FE5E29CB1118D32  # 0.683912607038 1005
+    .quad 0x03FE5E29CB1118D32
+    .quad 0x03FE5E6938645D390  # 0.684396517040 1006
+    .quad 0x03FE5E6938645D390
+    .quad 0x03FE5EA8AD9419C5B  # 0.684880661324 1007
+    .quad 0x03FE5EA8AD9419C5B
+    .quad 0x03FE5EE82AA241920  # 0.685365040118 1008
+    .quad 0x03FE5EE82AA241920
+    .quad 0x03FE5F27AF90C8705  # 0.685849653648 1009
+    .quad 0x03FE5F27AF90C8705
+    .quad 0x03FE5F673C61A2ED2  # 0.686334502142 1010
+    .quad 0x03FE5F673C61A2ED2
+    .quad 0x03FE5FA6D116C64F7  # 0.686819585829 1011
+    .quad 0x03FE5FA6D116C64F7
+    .quad 0x03FE5FE66DB228992  # 0.687304904936 1012
+    .quad 0x03FE5FE66DB228992
+    .quad 0x03FE60261235C0874  # 0.687790459692 1013
+    .quad 0x03FE60261235C0874
+    .quad 0x03FE6065BEA385926  # 0.688276250325 1014
+    .quad 0x03FE6065BEA385926
+    .quad 0x03FE60A572FD6FEF1  # 0.688762277066 1015
+    .quad 0x03FE60A572FD6FEF1
+    .quad 0x03FE60E52F45788E4  # 0.689248540144 1016
+    .quad 0x03FE60E52F45788E4
+    .quad 0x03FE6124F37D991D4  # 0.689735039789 1017
+    .quad 0x03FE6124F37D991D4
+    .quad 0x03FE6164BFA7CC06C  # 0.690221776231 1018
+    .quad 0x03FE6164BFA7CC06C
+    .quad 0x03FE61A493C60C729  # 0.690708749700 1019
+    .quad 0x03FE61A493C60C729
+    .quad 0x03FE61E46FDA56466  # 0.691195960429 1020
+    .quad 0x03FE61E46FDA56466
+    .quad 0x03FE622453E6A6263  # 0.691683408647 1021
+    .quad 0x03FE622453E6A6263
+    .quad 0x03FE62643FECF9743  # 0.692171094587 1022
+    .quad 0x03FE62643FECF9743
+    .quad 0x03FE62A433EF4E51A  # 0.692659018480 1023
+    .quad 0x03FE62A433EF4E51A
diff --git a/src/gas/vrdacos.S b/src/gas/vrdacos.S
new file mode 100644
index 0000000..5e2b3a4
--- /dev/null
+++ b/src/gas/vrdacos.S
@@ -0,0 +1,3118 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrdacos.s
+#
+# An array implementation of the cos libm function.
+#
+# Prototype:
+#
+#    void vrda_cos(int n, double *x, double *y);
+#
+#Computes Cosine of x for an array of input values.
+#Places the results into the supplied y array.
+#Does not perform error checking.
+#Denormal inputs may produce unexpected results
+#Author: Harsha Jagasia
+#Email:  harsha.jagasia@amd.com
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.data
+.align 16
+.L__real_7fffffffffffffff: 	.quad 0x07fffffffffffffff	#Sign bit zero
+				.quad 0x07fffffffffffffff
+.L__real_3ff0000000000000: 	.quad 0x03ff0000000000000	# 1.0
+				.quad 0x03ff0000000000000
+.L__real_v2p__27:		.quad 0x03e40000000000000	# 2p-27
+				.quad 0x03e40000000000000
+.L__real_3fe0000000000000: 	.quad 0x03fe0000000000000	# 0.5
+				.quad 0x03fe0000000000000
+.L__real_3fc5555555555555: 	.quad 0x03fc5555555555555	# 0.166666666666
+				.quad 0x03fc5555555555555
+.L__real_3fe45f306dc9c883: 	.quad 0x03fe45f306dc9c883	# twobypi
+				.quad 0x03fe45f306dc9c883
+.L__real_3ff921fb54400000: 	.quad 0x03ff921fb54400000	# piby2_1
+				.quad 0x03ff921fb54400000
+.L__real_3dd0b4611a626331: 	.quad 0x03dd0b4611a626331	# piby2_1tail
+				.quad 0x03dd0b4611a626331
+.L__real_3dd0b4611a600000: 	.quad 0x03dd0b4611a600000	# piby2_2
+				.quad 0x03dd0b4611a600000
+.L__real_3ba3198a2e037073: 	.quad 0x03ba3198a2e037073	# piby2_2tail
+				.quad 0x03ba3198a2e037073
+.L__real_fffffffff8000000: 	.quad 0x0fffffffff8000000	# mask for stripping head and tail
+				.quad 0x0fffffffff8000000
+.L__real_8000000000000000:	.quad 0x08000000000000000	# -0  or signbit
+				.quad 0x08000000000000000
+.L__reald_one_one:		.quad 0x00000000100000001	#
+				.quad 0
+.L__reald_two_two:		.quad 0x00000000200000002	#
+				.quad 0
+.L__reald_one_zero:		.quad 0x00000000100000000	# sin_cos_filter
+				.quad 0
+.L__reald_zero_one:		.quad 0x00000000000000001	#
+				.quad 0
+.L__reald_two_zero:		.quad 0x00000000200000000	#
+				.quad 0
+.L__realq_one_one:		.quad 0x00000000000000001	#
+				.quad 0x00000000000000001	#
+.L__realq_two_two:		.quad 0x00000000000000002	#
+				.quad 0x00000000000000002	#
+.L__real_1_x_mask:		.quad 0x0ffffffffffffffff	#
+				.quad 0x03ff0000000000000	#
+.L__real_zero:			.quad 0x00000000000000000	#
+				.quad 0x00000000000000000	#
+.L__real_one:			.quad 0x00000000000000001	#
+				.quad 0x00000000000000001	#
+
+.Lcosarray:
+	.quad	0x03fa5555555555555		# 0.0416667		   	c1
+	.quad	0x03fa5555555555555
+	.quad	0x0bf56c16c16c16967		# -0.00138889	   		c2
+	.quad	0x0bf56c16c16c16967
+	.quad	0x03efa01a019f4ec90		# 2.48016e-005			c3
+	.quad	0x03efa01a019f4ec90
+	.quad	0x0be927e4fa17f65f6		# -2.75573e-007			c4
+	.quad	0x0be927e4fa17f65f6
+	.quad	0x03e21eeb69037ab78		# 2.08761e-009			c5
+	.quad	0x03e21eeb69037ab78
+	.quad	0x0bda907db46cc5e42		# -1.13826e-011	   		c6
+	.quad	0x0bda907db46cc5e42
+.Lsinarray:
+	.quad	0x0bfc5555555555555		# -0.166667	   		s1
+	.quad	0x0bfc5555555555555
+	.quad	0x03f81111111110bb3		# 0.00833333	   		s2
+	.quad	0x03f81111111110bb3
+	.quad	0x0bf2a01a019e83e5c		# -0.000198413			s3
+	.quad	0x0bf2a01a019e83e5c
+	.quad	0x03ec71de3796cde01		# 2.75573e-006			s4
+	.quad	0x03ec71de3796cde01
+	.quad	0x0be5ae600b42fdfa7		# -2.50511e-008			s5
+	.quad	0x0be5ae600b42fdfa7
+	.quad	0x03de5e0b2f9a43bb8		# 1.59181e-010	   		s6
+	.quad	0x03de5e0b2f9a43bb8
+.Lsincosarray:
+	.quad	0x0bfc5555555555555		# -0.166667	   		s1
+	.quad	0x03fa5555555555555		# 0.0416667		   	c1
+	.quad	0x03f81111111110bb3		# 0.00833333	   		s2
+	.quad	0x0bf56c16c16c16967
+	.quad	0x0bf2a01a019e83e5c		# -0.000198413			s3
+	.quad	0x03efa01a019f4ec90
+	.quad	0x03ec71de3796cde01		# 2.75573e-006			s4
+	.quad	0x0be927e4fa17f65f6
+	.quad	0x0be5ae600b42fdfa7		# -2.50511e-008			s5
+	.quad	0x03e21eeb69037ab78
+	.quad	0x03de5e0b2f9a43bb8		# 1.59181e-010	   		s6
+	.quad	0x0bda907db46cc5e42
+.Lcossinarray:
+	.quad	0x03fa5555555555555		# 0.0416667		   	c1
+	.quad	0x0bfc5555555555555		# -0.166667	   		s1
+	.quad	0x0bf56c16c16c16967
+	.quad	0x03f81111111110bb3		# 0.00833333	   		s2
+	.quad	0x03efa01a019f4ec90
+	.quad	0x0bf2a01a019e83e5c		# -0.000198413			s3
+	.quad	0x0be927e4fa17f65f6
+	.quad	0x03ec71de3796cde01		# 2.75573e-006			s4
+	.quad	0x03e21eeb69037ab78
+	.quad	0x0be5ae600b42fdfa7		# -2.50511e-008			s5
+	.quad	0x0bda907db46cc5e42
+	.quad	0x03de5e0b2f9a43bb8		# 1.59181e-010	   		s6
+
+.align 16
+.Levencos_oddsin_tbl:
+		.quad	.Lcoscos_coscos_piby4		# 0		*
+		.quad	.Lcoscos_cossin_piby4		# 1		+
+		.quad	.Lcoscos_sincos_piby4		# 2
+		.quad	.Lcoscos_sinsin_piby4		# 3		+
+
+		.quad	.Lcossin_coscos_piby4		# 4
+		.quad	.Lcossin_cossin_piby4		# 5		*
+		.quad	.Lcossin_sincos_piby4		# 6
+		.quad	.Lcossin_sinsin_piby4		# 7
+
+		.quad	.Lsincos_coscos_piby4		# 8
+		.quad	.Lsincos_cossin_piby4		# 9
+		.quad	.Lsincos_sincos_piby4		# 10		*
+		.quad	.Lsincos_sinsin_piby4		# 11
+
+		.quad	.Lsinsin_coscos_piby4		# 12
+		.quad	.Lsinsin_cossin_piby4		# 13		+
+		.quad	.Lsinsin_sincos_piby4		# 14
+		.quad	.Lsinsin_sinsin_piby4		# 15		*
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+        .weak vrda_cos_
+        .set vrda_cos_,__vrda_cos__
+        .weak vrda_cos__
+        .set vrda_cos__,__vrda_cos__
+
+    .text
+    .align 16
+    .p2align 4,,15
+
+#x/* a FORTRAN subroutine implementation of array cos
+#**     VRDA_COS(N,X,Y)
+# C equivalent*/
+#void vrda_cos__(int * n, double *x, double *y)
+#{
+#       vrda_cos(*n,x,y);
+#}
+.globl __vrda_cos__
+    .type   __vrda_cos__,@function
+__vrda_cos__:
+    mov         (%rdi),%edi
+
+    .align 16
+    .p2align 4,,15
+
+# define local variable storage offsets
+.equ	p_temp,		0x00		# temporary for get/put bits operation
+.equ	p_temp1,	0x10		# temporary for get/put bits operation
+
+.equ	p_xmm6,		0x20		# temporary for get/put bits operation
+.equ	p_xmm7,		0x30		# temporary for get/put bits operation
+.equ	p_xmm8,		0x40		# temporary for get/put bits operation
+.equ	p_xmm9,		0x50		# temporary for get/put bits operation
+.equ	p_xmm10,	0x60		# temporary for get/put bits operation
+.equ	p_xmm11,	0x70		# temporary for get/put bits operation
+.equ	p_xmm12,	0x80		# temporary for get/put bits operation
+.equ	p_xmm13,	0x90		# temporary for get/put bits operation
+.equ	p_xmm14,	0x0A0		# temporary for get/put bits operation
+.equ	p_xmm15,	0x0B0		# temporary for get/put bits operation
+
+.equ	r,		0x0C0		# pointer to r for remainder_piby2
+.equ	rr,		0x0D0		# pointer to r for remainder_piby2
+.equ	region,		0x0E0		# pointer to r for remainder_piby2
+
+.equ	r1,		0x0F0		# pointer to r for remainder_piby2
+.equ	rr1,		0x0100		# pointer to r for remainder_piby2
+.equ	region1,	0x0110		# pointer to r for remainder_piby2
+
+.equ	p_temp2,	0x0120		# temporary for get/put bits operation
+.equ	p_temp3,	0x0130		# temporary for get/put bits operation
+
+.equ	p_temp4,	0x0140		# temporary for get/put bits operation
+.equ	p_temp5,	0x0150		# temporary for get/put bits operation
+
+.equ	p_original,	0x0160		# original x
+.equ	p_mask,		0x0170		# original x
+.equ	p_sign,		0x0180		# original x
+
+.equ	p_original1,	0x0190		# original x
+.equ	p_mask1,	0x01A0		# original x
+.equ	p_sign1,	0x01B0		# original x
+
+.equ	save_xa,	0x01C0		#qword
+.equ	save_ya,	0x01D0		#qword
+
+.equ	save_nv,	0x01E0		#qword
+.equ	p_iter,		0x01F0		#qword	storage for number of loop iterations
+
+
+.globl vrda_cos
+    .type   vrda_cos,@function
+vrda_cos:
+# parameters are passed in by Linux C as:
+# edi - int n
+# rsi - double *x
+# rdx - double *y
+
+
+	sub		$0x208,%rsp
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#START PROCESS INPUT
+# save the arguments
+	mov		%rsi,save_xa(%rsp)		# save x_array pointer
+	mov		%rdx,save_ya(%rsp)		# save y_array pointer
+#ifdef INTEGER64
+        mov             %rdi,%rax
+#else
+        mov             %edi,%eax
+        mov             %rax,%rdi
+#endif
+	mov		%rdi,save_nv(%rsp)		# save number of values
+
+# see if too few values to call the main loop
+	shr		$2,%rax				# get number of iterations
+	jz		.L__vrda_cleanup		# jump if only single calls
+
+# prepare the iteration counts
+	mov		%rax,p_iter(%rsp)		# save number of iterations
+	shl		$2,%rax
+	sub		%rax,%rdi			# compute number of extra single calls
+	mov		%rdi,save_nv(%rsp)		# save number of left over values
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#START LOOP
+.align 16
+.L__vrda_top:
+# build the input _m128d
+	movapd		.L__real_7fffffffffffffff(%rip),%xmm2
+	mov		save_xa(%rsp),%rsi	# get x_array pointer
+	movlpd		(%rsi),%xmm0
+	movhpd		8(%rsi),%xmm0
+
+	prefetch	64(%rsi)
+	add		$32,%rsi
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+
+	movdqa	 %xmm0,p_original(%rsp)
+	movlpd	 -16(%rsi), %xmm1
+	movhpd	 -8(%rsi),  %xmm1
+	movdqa	 %xmm1,p_original1(%rsp)
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#STARTMAIN
+
+andpd 	%xmm2,%xmm0				#Unsign
+andpd 	%xmm2,%xmm1				#Unsign
+
+movd	%xmm0,%rax				#rax is lower arg
+movhpd	%xmm0, p_temp+8(%rsp)			#
+mov    	p_temp+8(%rsp),%rcx			#rcx = upper arg
+movd	%xmm1,%r8				#rax is lower arg
+movhpd	%xmm1, p_temp1+8(%rsp)			#
+mov    	p_temp1+8(%rsp),%r9			#rcx = upper arg
+
+mov 	$0x3FE921FB54442D18,%rdx		#piby4	+
+mov	$0x411E848000000000,%r10		#5e5	+
+
+movapd	.L__real_3fe0000000000000(%rip),%xmm4	#0.5 for later use
+
+movapd	%xmm0,%xmm2				#x0
+movapd	%xmm1,%xmm3				#x1
+movapd	%xmm0,%xmm6				#x0
+movapd	%xmm1,%xmm7				#x1
+
+#DEBUG
+#	add		$0x1C8,%rsp
+#	ret
+#	movapd	%xmm0,%xmm4
+#	movapd	%xmm1,%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm2 = x, xmm4 =0.5/t, xmm6 =x
+# xmm3 = x, xmm5 =0.5/t, xmm7 =x
+.align 16
+.Leither_or_both_arg_gt_than_piby4:
+	cmp	%r10,%rax
+	jae	.Lfirst_or_next3_arg_gt_5e5
+
+	cmp	%r10,%rcx
+	jae	.Lsecond_or_next2_arg_gt_5e5
+
+	cmp	%r10,%r8
+	jae	.Lthird_or_fourth_arg_gt_5e5
+
+	cmp	%r10,%r9
+	jae	.Lfourth_arg_gt_5e5
+
+
+#      /* Find out what multiple of piby2 */
+#        npi2  = (int)(x * twobypi + 0.5);
+	movapd	.L__real_3fe45f306dc9c883(%rip),%xmm0
+	mulpd	%xmm0,%xmm2						# * twobypi
+	mulpd	%xmm0,%xmm3						# * twobypi
+
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	addpd	%xmm4,%xmm3						# +0.5, npi2
+
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm0		# piby2_1
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm1		# piby2_1
+
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	cvttpd2dq	%xmm3,%xmm5					# convert packed double to packed integers
+
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm9		# piby2_2
+
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+	cvtdq2pd	%xmm5,%xmm3					# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+
+	movd	%xmm4,%rax						# Region
+	movd	%xmm5,%rcx						# Region
+
+	mov	%rax,%r8
+	mov	%rcx,%r9
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm0						# npi2 * piby2_1;
+       mulpd	%xmm3,%xmm1						# npi2 * piby2_1;
+
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+       mulpd	%xmm3,%xmm9						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm0,%xmm6						# rhead  = x - npi2 * piby2_1;
+       subpd	%xmm1,%xmm7						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm0						# t
+       movapd	%xmm7,%xmm1						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm0						# rhead
+       subpd	%xmm9,%xmm1						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm3		# npi2 * piby2_2tail
+
+       subpd	%xmm0,%xmm6						# t-rhead
+       subpd	%xmm1,%xmm7						# t-rhead
+
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       subpd	%xmm7,%xmm9						# - ((t - rhead) - rtail)
+
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       addpd	%xmm3,%xmm9						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm4  = npi2 (int), xmm0 =rhead, xmm8 =rtail
+# xmm5  = npi2 (int), xmm1 =rhead, xmm9 =rtail
+
+#	paddd		.L__reald_one_one(%rip),%xmm4		; Sign
+#	paddd		.L__reald_one_one(%rip),%xmm5		; Sign
+#	pand		.L__reald_two_two(%rip),%xmm4
+#	pand		.L__reald_two_two(%rip),%xmm5
+#	punpckldq 	%xmm4,%xmm4
+#	punpckldq 	%xmm5,%xmm5
+#	psllq		$62,%xmm4
+#	psllq		$62,%xmm5
+
+
+	add .L__reald_one_one(%rip),%r8
+	add .L__reald_one_one(%rip),%r9
+	and .L__reald_two_two(%rip),%r8
+	and .L__reald_two_two(%rip),%r9
+
+	mov %r8,%r10
+	mov %r9,%r11
+	shl $62,%r8
+	and .L__reald_two_zero(%rip),%r10
+	shl $30,%r10
+	shl $62,%r9
+	and .L__reald_two_zero(%rip),%r11
+	shl $30,%r11
+
+	mov	 %r8,p_sign(%rsp)
+	mov	 %r10,p_sign+8(%rsp)
+	mov	 %r9,p_sign1(%rsp)
+	mov	 %r11,p_sign1+8(%rsp)
+
+# GET_BITS_DP64(rhead-rtail, uy);			   		; originally only rhead
+# xmm4  = Sign, xmm0 =rhead, xmm8 =rtail
+# xmm5  = Sign, xmm1 =rhead, xmm9 =rtail
+	movapd	%xmm0,%xmm6						# rhead
+	movapd	%xmm1,%xmm7						# rhead
+
+	and	.L__reald_one_one(%rip),%rax		# Region
+	and	.L__reald_one_one(%rip),%rcx		# Region
+
+	subpd	%xmm8,%xmm0						# r = rhead - rtail
+	subpd	%xmm9,%xmm1						# r = rhead - rtail
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm4  = Sign, xmm0 = r, xmm6 =rhead, xmm8 =rtail
+# xmm5  = Sign, xmm1 = r, xmm7 =rhead, xmm9 =rtail
+
+	subpd	%xmm0,%xmm6				#rr=rhead-r
+	subpd	%xmm1,%xmm7				#rr=rhead-r
+
+	mov	%rax,%r8
+	mov	%rcx,%r9
+
+	movapd	%xmm0,%xmm2
+	movapd	%xmm1,%xmm3
+
+	mulpd	%xmm0,%xmm2				# r2
+	mulpd	%xmm1,%xmm3				# r2
+
+	subpd	%xmm8,%xmm6				#rr=(rhead-r) -rtail
+	subpd	%xmm9,%xmm7				#rr=(rhead-r) -rtail
+
+
+	and	.L__reald_zero_one(%rip),%rax
+	and	.L__reald_zero_one(%rip),%rcx
+	shr	$31,%r8
+	shr	$31,%r9
+	or	%r8,%rax
+	or	%r9,%rcx
+	shl	$2,%rcx
+	or	%rcx,%rax
+
+	leaq	 .Levencos_oddsin_tbl(%rip),%rsi
+	jmp	 *(%rsi,%rax,8)				#Jmp table for cos/sin calculation based on even/odd region
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lfirst_or_next3_arg_gt_5e5:
+# %rcx,,%rax r8, r9
+
+#DEBUG
+#	movapd	%xmm0,%xmm4
+#	movapd	%xmm1,%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+	cmp	%r10,%rcx				#is upper arg >= 5e5
+	jae	.Lboth_arg_gt_5e5
+
+.Llower_arg_gt_5e5:
+# Upper Arg is < 5e5, Lower arg is >= 5e5
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+# Be sure not to use %xmm3,%xmm1 and xmm7
+# Use %xmm8,,%xmm5 xmm10, xmm12
+#	    %xmm11,,%xmm9 xmm13
+
+
+#DEBUG
+#	movapd	%xmm0,%xmm4
+#	movapd	%xmm1,%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+
+	movlpd	 %xmm0,r(%rsp)		#Save lower fp arg for remainder_piby2 call
+	movhlps	%xmm0,%xmm0			#Needed since we want to work on upper arg
+	movhlps	%xmm2,%xmm2
+	movhlps	%xmm6,%xmm6
+
+# Work on Upper arg
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm4,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm8		# xmm8 = piby2_1
+	cvttsd2si	%xmm2,%ecx				# ecx = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm10		# xmm10 = piby2_2
+	cvtsi2sd	%ecx,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm8					# npi2 * piby2_1
+	subsd	%xmm8,%xmm6					# xmm6 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm12		# xmm12 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm6,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm10					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm10,%xmm6					# xmm6 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm12     					# npi2 * piby2_2tail
+       subsd	%xmm6,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm10					# (rtail-(t-rhead))
+       addsd	%xmm12,%xmm10					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %ecx,region+4(%rsp)			# store upper region
+       movsd	 %xmm6,%xmm0
+       subsd	 %xmm10,%xmm0					# xmm0 = r=(rhead-rtail)
+       subsd	 %xmm0,%xmm6					# rr=rhead-r
+       subsd	 %xmm10,%xmm6					# xmm6 = rr=((rhead-r) -rtail)
+       movlpd	 %xmm0,r+8(%rsp)			# store upper r
+       movlpd	 %xmm6,rr+8(%rsp)			# store upper rr
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#Note that volatiles will be trashed by the call
+#We will construct r, rr, region and sign
+
+# Work on Lower arg
+	mov		$0x07ff0000000000000,%r11			# is lower arg nan/inf
+	mov		%r11,%r10
+	and		%rax,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_cos_lower_naninf
+
+
+	mov	  %r8,p_temp(%rsp)
+	mov	  %r9,p_temp2(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region(%rsp),%rdx			# lower arg is **NOT** nan/inf
+	lea	 rr(%rsp),%rsi
+	lea	 r(%rsp),%rdi
+	movlpd	 r(%rsp),%xmm0	#Restore lower fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+
+	mov	 p_temp(%rsp),%r8
+	mov	 p_temp2(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+	jmp 	0f
+
+.L__vrd4_cos_lower_naninf:
+	mov	p_original(%rsp),%rax			# upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rax
+	mov	 %rax,r(%rsp)				# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr(%rsp)				# rr = 0
+	mov	 %r10d,region(%rsp)			# region =0
+
+.align 16
+0:
+
+
+#DEBUG
+#	movapd	.LOWORD,%xmm4 PTR r[rsp]
+#	movapd	%xmm1,%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+
+
+	jmp 	.Lcheck_next2_args
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lboth_arg_gt_5e5:
+#Upper Arg is >= 5e5, Lower arg is >= 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+
+
+#DEBUG
+#	movapd	%xmm0,%xmm4
+#	movapd	%xmm1,%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+
+
+
+	movhpd 	%xmm0,r+8(%rsp)		#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r11			#is lower arg nan/inf
+	mov		%r11,%r10
+	and		%rax,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_cos_lower_naninf_of_both_gt_5e5
+
+	mov	  %rcx,p_temp(%rsp)			#Save upper arg
+	mov	  %r8,p_temp2(%rsp)
+	mov	  %r9,p_temp4(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	 rr(%rsp),%rsi
+	lea	 r(%rsp),%rdi
+        call    __amd_remainder_piby2@PLT
+
+	mov	 p_temp(%rsp),%rcx			#Restore upper arg
+	mov	 p_temp2(%rsp),%r8
+	mov	 p_temp4(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+
+	jmp 	0f
+
+.L__vrd4_cos_lower_naninf_of_both_gt_5e5:				#lower arg is nan/inf
+	mov	p_original(%rsp),%rax
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rax
+	mov	 %rax,r(%rsp)				#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr(%rsp)				#rr = 0
+	mov	 %r10d,region(%rsp)			#region = 0
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r11			#is upper arg nan/inf
+	mov		%r11,%r10
+	and		%rcx,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_cos_upper_naninf_of_both_gt_5e5
+
+
+	mov	  %r8,p_temp(%rsp)
+	mov	  %r9,p_temp2(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region+4(%rsp),%rdx			#upper arg is **NOT** nan/inf
+	lea	 rr+8(%rsp),%rsi
+	lea	 r+8(%rsp),%rdi
+	movlpd	 r+8(%rsp),%xmm0			#Restore upper fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+
+	mov	 p_temp(%rsp),%r8
+	mov	 p_temp2(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+
+	jmp 	0f
+
+.L__vrd4_cos_upper_naninf_of_both_gt_5e5:
+	mov	p_original+8(%rsp),%rcx		#upper arg is nan/inf
+#	movd	%xmm6,%rcx					;upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rcx
+	mov	%rcx,r+8(%rsp)				#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	%r10,rr+8(%rsp)			#rr = 0
+	mov	%r10d,region+4(%rsp)			#region = 0
+
+.align 16
+0:
+	jmp 	.Lcheck_next2_args
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lsecond_or_next2_arg_gt_5e5:
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+# Do not use %xmm3,,%xmm1 xmm7
+# Restore xmm4 and %xmm3,,%xmm1 xmm7
+# Can use %xmm10,,%xmm8 xmm12
+#   %xmm9,,%xmm5 xmm11, xmm13
+
+	movhpd	%xmm0,r+8(%rsp)	#Save upper fp arg for remainder_piby2 call
+#	movlhps	%xmm0,%xmm0			;Not needed since we want to work on lower arg, but done just to be safe and avoide exceptions due to nan/inf and to mirror the lower_arg_gt_5e5 case
+#	movlhps	%xmm2,%xmm2
+#	movlhps	%xmm6,%xmm6
+
+# Work on Lower arg
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm4,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm8		# xmm3 = piby2_1
+	cvttsd2si	%xmm2,%eax				# ecx = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm10		# xmm1 = piby2_2
+	cvtsi2sd	%eax,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm8					# npi2 * piby2_1
+	subsd	%xmm8,%xmm6					# xmm6 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm12		# xmm7 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm6,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm10					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm10,%xmm6					# xmm6 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm12     					# npi2 * piby2_2tail
+       subsd	%xmm6,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm10					# (rtail-(t-rhead))
+       addsd	%xmm12,%xmm10					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %eax,region(%rsp)			# store upper region
+       movsd	%xmm6,%xmm0
+       subsd	%xmm10,%xmm0					# xmm0 = r=(rhead-rtail)
+       subsd	%xmm0,%xmm6					# rr=rhead-r
+       subsd	%xmm10,%xmm6					# xmm6 = rr=((rhead-r) -rtail)
+       movlpd	 %xmm0,r(%rsp)				# store upper r
+       movlpd	 %xmm6,rr(%rsp)				# store upper rr
+
+#Work on Upper arg
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+	mov		$0x07ff0000000000000,%r11			# is upper arg nan/inf
+	mov		%r11,%r10
+	and		%rcx,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_cos_upper_naninf
+
+
+	mov	  %r8,p_temp(%rsp)
+	mov	  %r9,p_temp2(%rsp)
+	movapd	 %xmm1,p_temp1(%rsp)
+	movapd	 %xmm3,p_temp3(%rsp)
+	movapd	 %xmm7,p_temp5(%rsp)
+
+	lea	 region+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 rr+8(%rsp),%rsi
+	lea	 r+8(%rsp),%rdi
+	movlpd	 r+8(%rsp),%xmm0	#Restore upper fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+
+	mov	 p_temp(%rsp),%r8
+	mov	 p_temp2(%rsp),%r9
+	movapd	p_temp1(%rsp),%xmm1
+	movapd	p_temp3(%rsp),%xmm3
+	movapd	p_temp5(%rsp),%xmm7
+	jmp 	0f
+
+.L__vrd4_cos_upper_naninf:
+	mov	p_original+8(%rsp),%rcx		# upper arg is nan/inf
+#	mov	r+8(%rsp),%rcx				; upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rcx
+	mov	 %rcx,r+8(%rsp)				# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr+8(%rsp)			# rr = 0
+	mov	 %r10d,region+4(%rsp)			# region =0
+
+.align 16
+0:
+	jmp 	.Lcheck_next2_args
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcheck_next2_args:
+
+#DEBUG
+#	movapd	r(%rsp),%xmm4
+#	movapd	%xmm1,%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+	mov	$0x411E848000000000,%r10			#5e5	+
+
+	cmp	%r10,%r8
+	jae	.Lfirst_second_done_third_or_fourth_arg_gt_5e5
+
+	cmp	%r10,%r9
+	jae	.Lfirst_second_done_fourth_arg_gt_5e5
+
+# Work on next two args, both < 5e5
+# %xmm3,,%xmm1 xmm5 = x, xmm4 = 0.5
+
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4			#Restore 0.5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm3						# * twobypi
+	addpd	%xmm4,%xmm3						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm1		# piby2_1
+	cvttpd2dq	%xmm3,%xmm5					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm9		# piby2_2
+	cvtdq2pd	%xmm5,%xmm3					# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movq	 %xmm5,region1(%rsp)						# Region
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm3,%xmm1						# npi2 * piby2_1;
+
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm3,%xmm9						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm1,%xmm7						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm7,%xmm1						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm9,%xmm1						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm3		# npi2 * piby2_2tail
+
+       subpd	%xmm1,%xmm7						# t-rhead
+       subpd	%xmm7,%xmm9						# - ((t - rhead) - rtail)
+       addpd	%xmm3,%xmm9						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+       movapd	%xmm1,%xmm7						# rhead
+       subpd	%xmm9,%xmm1						# r = rhead - rtail
+       movapd	 %xmm1,r1(%rsp)
+
+       subpd	%xmm1,%xmm7						# rr=rhead-r
+       subpd	%xmm9,%xmm7						# rr=(rhead-r) -rtail
+       movapd	 %xmm7,rr1(%rsp)
+
+	jmp	.L__vrd4_cos_reconstruct
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lthird_or_fourth_arg_gt_5e5:
+#first two args are < 5e5, third arg >= 5e5, fourth arg >= 5e5 or < 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+# Do not use %xmm3,,%xmm1 xmm7
+# Can use 	%xmm11,,%xmm9 xmm13
+# 	%xmm8,,%xmm5 xmm10, xmm12
+# Restore xmm4
+
+# Work on first two args, both < 5e5
+
+#DEBUG
+#	movapd	%xmm0,%xmm4
+#	movapd	%xmm1,%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm2						# * twobypi
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm0		# piby2_1
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movq	 %xmm4,region(%rsp)						# Region
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm0						# npi2 * piby2_1;
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm0,%xmm6						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm0						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm0						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+
+       subpd	%xmm0,%xmm6						# t-rhead
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+       movapd	%xmm0,%xmm6						# rhead
+       subpd	%xmm8,%xmm0						# r = rhead - rtail
+       movapd	 %xmm0,r(%rsp)
+
+       subpd	%xmm0,%xmm6						# rr=rhead-r
+       subpd	%xmm8,%xmm6						# rr=(rhead-r) -rtail
+       movapd	 %xmm6,rr(%rsp)
+
+
+# Work on next two args, third arg >= 5e5, fourth arg >= 5e5 or < 5e5
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lfirst_second_done_third_or_fourth_arg_gt_5e5:
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+
+
+#DEBUG
+#	movapd	r(%rsp),%xmm4
+#	movapd	%xmm1,%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+	mov	$0x411E848000000000,%r10			#5e5	+
+	cmp	%r10,%r9
+	jae	.Lboth_arg_gt_5e5_higher
+
+
+# Upper Arg is <5e5, Lower arg is >= 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+	movlpd	 %xmm1,r1(%rsp)		#Save lower fp arg for remainder_piby2 call
+	movhlps	%xmm1,%xmm1			#Needed since we want to work on upper arg
+	movhlps	%xmm3,%xmm3
+	movhlps	%xmm7,%xmm7
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4	#0.5 for later use
+
+# Work on Upper arg
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm3		# x*twobypi
+	addsd	%xmm4,%xmm3					# xmm3 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm2		# xmm2 = piby2_1
+	cvttsd2si	%xmm3,%r9d				# r9d = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm0		# xmm0 = piby2_2
+	cvtsi2sd	%r9d,%xmm3				# xmm3 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm3,%xmm2					# npi2 * piby2_1
+	subsd	%xmm2,%xmm7					# xmm7 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm7,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm3,%xmm0					# xmm0 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm0,%xmm7					# xmm7 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm3,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm7,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm0					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm0					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %r9d,region1+4(%rsp)			# store upper region
+       movsd	%xmm7,%xmm1
+       subsd	%xmm0,%xmm1					# xmm1 = r=(rhead-rtail)
+       subsd	%xmm1,%xmm7					# rr=rhead-r
+       subsd	%xmm0,%xmm7					# xmm7 = rr=((rhead-r) -rtail)
+       movlpd	 %xmm1,r1+8(%rsp)			# store upper r
+       movlpd	 %xmm7,rr1+8(%rsp)			# store upper rr
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+
+# Work on Lower arg
+	mov		$0x07ff0000000000000,%r11			# is lower arg nan/inf
+	mov		%r11,%r10
+	and		%r8,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_cos_lower_naninf_higher
+
+	lea	 region1(%rsp),%rdx			# lower arg is **NOT** nan/inf
+	lea	 rr1(%rsp),%rsi
+	lea	 r1(%rsp),%rdi
+	movlpd	 r1(%rsp),%xmm0				#Restore lower fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+	jmp 	0f
+
+.L__vrd4_cos_lower_naninf_higher:
+	mov	p_original1(%rsp),%r8			# upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r8
+	mov	 %r8,r1(%rsp)				# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr1(%rsp)				# rr = 0
+	mov	 %r10d,region1(%rsp)			# region =0
+
+.align 16
+0:
+
+
+#DEBUG
+#	movapd	rr(%rsp),%xmm4
+#	movapd	rr1(%rsp),%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+	jmp 	.L__vrd4_cos_reconstruct
+
+
+
+
+
+
+
+.align 16
+.Lboth_arg_gt_5e5_higher:
+# Upper Arg is >= 5e5, Lower arg is >= 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+
+#DEBUG
+#	movapd	r(%rsp),%xmm4
+#	movd	%r8,%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+	movhpd 	%xmm1,r1+8(%rsp)				#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r11			#is lower arg nan/inf
+	mov		%r11,%r10
+	and		%r8,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_cos_lower_naninf_of_both_gt_5e5_higher
+
+	mov	  %r9,p_temp1(%rsp)			#Save upper arg
+	lea	 region1(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	 rr1(%rsp),%rsi
+	lea	 r1(%rsp),%rdi
+	movsd	 %xmm1,%xmm0
+        call    __amd_remainder_piby2@PLT
+	mov	 p_temp1(%rsp),%r9			#Restore upper arg
+
+
+#DEBUG
+#	movapd	 r(%rsp),%xmm4
+#	mov	 QWORD PTR r1[rsp+8], r9
+#	movapd	 r1(%rsp),%xmm5
+#	xorpd	 %xmm0,%xmm0
+#	xorpd	 %xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+
+
+	jmp 	0f
+
+.L__vrd4_cos_lower_naninf_of_both_gt_5e5_higher:				#lower arg is nan/inf
+	mov	p_original1(%rsp),%r8
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r8
+	mov	 %r8,r1(%rsp)				#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr1(%rsp)				#rr = 0
+	mov	 %r10d,region1(%rsp)			#region = 0
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r11			#is upper arg nan/inf
+	mov		%r11,%r10
+	and		%r9,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_cos_upper_naninf_of_both_gt_5e5_higher
+
+	lea	 region1+4(%rsp),%rdx			#upper arg is **NOT** nan/inf
+	lea	 rr1+8(%rsp),%rsi
+	lea	 r1+8(%rsp),%rdi
+	movlpd	 r1+8(%rsp),%xmm0			#Restore upper fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+	jmp 	0f
+
+.L__vrd4_cos_upper_naninf_of_both_gt_5e5_higher:
+	mov	p_original1+8(%rsp),%r9		#upper arg is nan/inf
+#	movd	%xmm6,%r9					;upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r9
+	mov	 %r9,r1+8(%rsp)				#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr1+8(%rsp)			#rr = 0
+	mov	 %r10d,region1+4(%rsp)			#region = 0
+
+.align 16
+0:
+
+#DEBUG
+#	movapd	r(%rsp),%xmm4
+#	movapd	r1(%rsp),%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+
+	jmp 	.L__vrd4_cos_reconstruct
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lfourth_arg_gt_5e5:
+#first two args are < 5e5, third arg < 5e5, fourth arg >= 5e5
+#%rcx,,%rax r8, r9
+#%xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+
+# Work on first two args, both < 5e5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm2						# * twobypi
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm0		# piby2_1
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movq	 %xmm4,region(%rsp)						# Region
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm0						# npi2 * piby2_1;
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm0,%xmm6						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm0						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm0						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+
+       subpd	%xmm0,%xmm6						# t-rhead
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+       movapd	%xmm0,%xmm6						# rhead
+       subpd	%xmm8,%xmm0						# r = rhead - rtail
+       movapd	 %xmm0,r(%rsp)
+
+       subpd	%xmm0,%xmm6						# rr=rhead-r
+       subpd	%xmm8,%xmm6						# rr=(rhead-r) -rtail
+       movapd	 %xmm6,rr(%rsp)
+
+
+# Work on next two args, third arg < 5e5, fourth arg >= 5e5
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lfirst_second_done_fourth_arg_gt_5e5:
+
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+	movhpd	 %xmm1,r1+8(%rsp)	#Save upper fp arg for remainder_piby2 call
+#	movlhps	%xmm1,%xmm1			;Not needed since we want to work on lower arg, but done just to be safe and avoide exceptions due to nan/inf and to mirror the lower_arg_gt_5e5 case
+#	movlhps	%xmm3,%xmm3
+#	movlhps	%xmm7,%xmm7
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4	#0.5 for later use
+
+# Work on Lower arg
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm3		# x*twobypi
+	addsd	%xmm4,%xmm3					# xmm3 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm2		# xmm2 = piby2_1
+	cvttsd2si	%xmm3,%r8d				# r8d = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm0		# xmm0 = piby2_2
+	cvtsi2sd	%r8d,%xmm3				# xmm3 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm3,%xmm2					# npi2 * piby2_1
+	subsd	%xmm2,%xmm7					# xmm7 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm7,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm3,%xmm0					# xmm0 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm0,%xmm7					# xmm7 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm3,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm7,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm0					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm0					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %r8d,region1(%rsp)			# store lower region
+       movsd	%xmm7,%xmm1
+       subsd	%xmm0,%xmm1					# xmm0 = r=(rhead-rtail)
+       subsd	%xmm1,%xmm7					# rr=rhead-r
+       subsd	%xmm0,%xmm7					# xmm6 = rr=((rhead-r) -rtail)
+
+       movlpd	 %xmm1,r1(%rsp)				# store upper r
+       movlpd	 %xmm7,rr1(%rsp)				# store upper rr
+
+#Work on Upper arg
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+	mov		$0x07ff0000000000000,%r11			# is upper arg nan/inf
+	mov		%r11,%r10
+	and		%r9,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_cos_upper_naninf_higher
+
+	lea	 region1+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 rr1+8(%rsp),%rsi
+	lea	 r1+8(%rsp),%rdi
+	movlpd	 r1+8(%rsp),%xmm0	#Restore upper fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+	jmp 	0f
+
+.L__vrd4_cos_upper_naninf_higher:
+	mov	p_original1+8(%rsp),%r9		# upper arg is nan/inf
+#	mov	r1+8(%rsp),%r9			# upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r9
+	mov	 %r9,r1+8(%rsp)			# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr1+8(%rsp)		# rr = 0
+	mov	 %r10d,region1+4(%rsp)		# region =0
+
+.align 16
+0:
+	jmp	.L__vrd4_cos_reconstruct
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrd4_cos_reconstruct:
+#Results
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+#DEBUG
+#	movapd	region(%rsp),%xmm4
+#	movapd	region1(%rsp),%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+	movapd	r(%rsp),%xmm0
+	movapd	r1(%rsp),%xmm1
+
+	movapd	rr(%rsp),%xmm6
+	movapd	rr1(%rsp),%xmm7
+
+	mov	region(%rsp),%rax
+	mov	region1(%rsp),%rcx
+
+	mov	%rax,%r8
+	mov	%rcx,%r9
+
+	add .L__reald_one_one(%rip),%r8
+	add .L__reald_one_one(%rip),%r9
+	and .L__reald_two_two(%rip),%r8
+	and .L__reald_two_two(%rip),%r9
+
+	mov %r8,%r10
+	mov %r9,%r11
+	shl $62,%r8
+	and .L__reald_two_zero(%rip),%r10
+	shl $30,%r10
+	shl $62,%r9
+	and .L__reald_two_zero(%rip),%r11
+	shl $30,%r11
+
+	mov	 %r8,p_sign(%rsp)
+	mov	 %r10,p_sign+8(%rsp)
+	mov	 %r9,p_sign1(%rsp)
+	mov	 %r11,p_sign1+8(%rsp)
+
+	and	.L__reald_one_one(%rip),%rax		# Region
+	and	.L__reald_one_one(%rip),%rcx		# Region
+
+	mov	%rax,%r8
+	mov	%rcx,%r9
+
+	movapd	%xmm0,%xmm2
+	movapd	%xmm1,%xmm3
+
+	mulpd	%xmm0,%xmm2				# r2
+	mulpd	%xmm1,%xmm3				# r2
+
+	and	.L__reald_zero_one(%rip),%rax
+	and	.L__reald_zero_one(%rip),%rcx
+	shr	$31,%r8
+	shr	$31,%r9
+	or	%r8,%rax
+	or	%r9,%rcx
+	shl	$2,%rcx
+	or	%rcx,%rax
+
+#DEBUG
+#	movd	%rax,%xmm4
+#	movd	%rax,%xmm5
+#	xorpd	%xmm0,%xmm0
+#	xorpd	%xmm1,%xmm1
+#	jmp 	.L__vrd4_cos_cleanup
+#DEBUG
+
+	leaq	 .Levencos_oddsin_tbl(%rip),%rsi
+	jmp	 *(%rsi,%rax,8)	#Jmp table for cos/sin calculation based on even/odd region
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrd4_cos_cleanup:
+
+	movapd	  p_sign(%rsp), %xmm0
+	movapd	  p_sign1(%rsp),%xmm1
+
+	xorpd	%xmm4,%xmm0			# (+) Sign
+	xorpd	%xmm5,%xmm1			# (+) Sign
+
+.L__vrda_bottom1:
+# store the result _m128d
+	mov	save_ya(%rsp),%rdi		# get y_array pointer
+	movlpd	%xmm0,(%rdi)
+	movhpd	%xmm0,8(%rdi)
+
+.L__vrda_bottom2:
+	prefetch	64(%rdi)
+	add		$32,%rdi
+	mov		%rdi,save_ya(%rsp)	# save y_array pointer
+
+# store the result _m128d
+	movlpd	%xmm1, -16(%rdi)
+	movhpd	%xmm1, -8(%rdi)
+
+	mov	p_iter(%rsp),%rax	# get number of iterations
+	sub	$1,%rax
+	mov	%rax,p_iter(%rsp)	# save number of iterations
+	jnz	.L__vrda_top
+
+# see if we need to do any extras
+	mov	save_nv(%rsp),%rax	# get number of values
+	test	%rax,%rax
+	jnz	.L__vrda_cleanup
+
+.L__final_check:
+	add	$0x208,%rsp
+	ret
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# we jump here when we have an odd number of cos calls to make at the end
+# we assume that rdx is pointing at the next x array element, r8 at the next y array element.
+# The number of values left is in save_nv
+
+.align	16
+.L__vrda_cleanup:
+        mov             save_nv(%rsp),%rax      # get number of values
+        test            %rax,%rax               # are there any values
+        jz              .L__final_check         # exit if not
+
+	mov		 save_xa(%rsp),%rsi
+	mov		 save_ya(%rsp),%rdi
+
+# fill in a m128d with zeroes and the extra values and then make a recursive call.
+	xorpd		 %xmm0,%xmm0
+	movlpd		 %xmm0,p_temp+8(%rsp)
+	movapd		 %xmm0,p_temp+16(%rsp)
+
+	mov		 (%rsi),%rcx			# we know there's at least one
+	mov	 	 %rcx,p_temp(%rsp)
+	cmp		 $2,%rax
+	jl		 .L__vrdacg
+
+	mov		 8(%rsi),%rcx			# do the second value
+	mov	 	 %rcx,p_temp+8(%rsp)
+	cmp		 $3,%rax
+	jl		 .L__vrdacg
+
+	mov		 16(%rsi),%rcx			# do the third value
+	mov	 	 %rcx,p_temp+16(%rsp)
+
+.L__vrdacg:
+	mov		 $4,%rdi				# parameter for N
+	lea		 p_temp(%rsp),%rsi			# &x parameter
+	lea		 p_temp2(%rsp),%rdx 			# &y parameter
+        call    	 vrda_cos@PLT
+
+# now copy the results to the destination array
+	mov		  save_ya(%rsp),%rdi
+	mov		  save_nv(%rsp),%rax		# get number of values
+	mov	 	  p_temp2(%rsp),%rcx
+	mov		  %rcx, (%rdi)			# we know there's at least one
+	cmp		  $2,%rax
+	jl		  .L__vrdacgf
+
+	mov	 	  p_temp2+8(%rsp),%rcx
+	mov		  %rcx, 8(%rdi)			# do the second value
+	cmp		  $3,%rax
+	jl		  .L__vrdacgf
+
+	mov	 	  p_temp2+16(%rsp),%rcx
+	mov		  %rcx, 16(%rdi)		# do the third value
+
+.L__vrdacgf:
+	jmp		  .L__final_check
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;JUMP TABLE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcoscos_coscos_piby4:
+	movapd	%xmm2,%xmm10					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lcosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lcosarray+0x50(%rip),%xmm5			# c6
+
+	movapd	.Lcosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lcosarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	 %xmm2,%xmm4					# c6*x2
+	mulpd	 %xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# r
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+
+	mulpd	 %xmm2,%xmm8					# c3*x2
+	mulpd	 %xmm3,%xmm9					# c3*x2
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm10		# -t=r-1.0	;trash r
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11		# -t=r-1.0	;trash r
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lcosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lcosarray+0x40(%rip),%xmm5			# c5+x2c6
+
+	addpd	.Lcosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lcosarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm10		# 1 + (-t)	;trash t
+	addpd   .L__real_3ff0000000000000(%rip),%xmm11		# 1 + (-t)	;trash t
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lcosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+
+	addpd	.Lcosarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lcosarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm2,%xmm2					# x4 recalculate
+	mulpd	%xmm3,%xmm3					# x4 recalculate
+
+	movapd   p_temp2(%rsp),%xmm12			# r
+	movapd   p_temp3(%rsp),%xmm13			# r
+
+	mulpd	%xmm0,%xmm6					# x * xx
+	mulpd	%xmm1,%xmm7					# x * xx
+
+	subpd   %xmm12,%xmm10					# (1 + (-t)) - r
+	subpd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x4 * zc
+
+	subpd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx
+	subpd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	addpd   %xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addpd   %xmm11,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm12		# t relaculate, -t = r-1
+	subpd	.L__real_3ff0000000000000(%rip),%xmm13		# t relaculate, -t = r-1
+
+	subpd   %xmm12,%xmm4					# + t
+	subpd   %xmm13,%xmm5					# + t
+
+	jmp 	.L__vrd4_cos_cleanup
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcossin_cossin_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	movapd	 %xmm6,p_temp(%rsp)		# Store rr
+	movapd	 %xmm7,p_temp1(%rsp)		# Store rr
+
+	movdqa	.Lsincosarray+0x50(%rip),%xmm4		# s6
+	movdqa	.Lsincosarray+0x50(%rip),%xmm5		# s6
+	movapd	.Lsincosarray+0x20(%rip),%xmm8		# s3
+	movapd	.Lsincosarray+0x20(%rip),%xmm9		# s3
+
+	movapd	%xmm2,%xmm10				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+
+	mulpd	%xmm2,%xmm4				# x2s6
+	mulpd	%xmm3,%xmm5				# x2s6
+	mulpd	%xmm2,%xmm8				# x2s3
+	mulpd	%xmm3,%xmm9				# x2s3
+
+	mulpd	%xmm2,%xmm10				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lsincosarray+0x40(%rip),%xmm4		# s5+x2s6
+	addpd	.Lsincosarray+0x40(%rip),%xmm5		# s5+x2s6
+	addpd	.Lsincosarray+0x10(%rip),%xmm8		# s2+x2s3
+	addpd	.Lsincosarray+0x10(%rip),%xmm9		# s2+x2s3
+
+	movapd	%xmm2,%xmm12				# move x2 for x6
+	movapd	%xmm3,%xmm13				# move x2 for x6
+
+	mulpd	%xmm2,%xmm4				# x2(s5+x2s6)
+	mulpd	%xmm3,%xmm5				# x2(s5+x2s6)
+	mulpd	%xmm2,%xmm8				# x2(s2+x2s3)
+	mulpd	%xmm3,%xmm9				# x2(s2+x2s3)
+
+	mulpd	%xmm10,%xmm12				# x6
+	mulpd	%xmm11,%xmm13				# x6
+
+	addpd	.Lsincosarray+0x30(%rip),%xmm4		# s4+x2(s5+x2s6)
+	addpd	.Lsincosarray+0x30(%rip),%xmm5		# s4+x2(s5+x2s6)
+	addpd	.Lsincosarray(%rip),%xmm8		# s1+x2(s2+x2s3)
+	addpd	.Lsincosarray(%rip),%xmm9		# s1+x2(s2+x2s3)
+
+	movhlps	%xmm10,%xmm10				# move high x4 for cos term
+	movhlps	%xmm11,%xmm11				# move high x4 for cos term
+	mulpd	%xmm12,%xmm4				# x6(s4+x2(s5+x2s6))
+	mulpd	%xmm13,%xmm5				# x6(s4+x2(s5+x2s6))
+
+	movsd	%xmm2,%xmm6				# move low x2 for x3 for sin term
+	movsd	%xmm3,%xmm7				# move low x2 for x3 for sin term
+	mulsd	%xmm0,%xmm6				# get low x3 for sin term
+	mulsd	%xmm1,%xmm7				# get low x3 for sin term
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for sin and cos terms
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for sin and cos terms
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm2,%xmm12				# move high r for cos
+	movhlps	%xmm3,%xmm13				# move high r for cos
+	movhlps	%xmm4,%xmm8				# xmm4 = sin , xmm8 = cos
+	movhlps	%xmm5,%xmm9				# xmm4 = sin , xmm8 = cos
+
+	mulsd	%xmm6,%xmm4				# sin *x3
+	mulsd	%xmm7,%xmm5				# sin *x3
+	mulsd	%xmm10,%xmm8				# cos *x4
+	mulsd	%xmm11,%xmm9				# cos *x4
+
+	mulsd	p_temp(%rsp),%xmm2		# 0.5 * x2 * xx for sin term
+	mulsd	p_temp1(%rsp),%xmm3		# 0.5 * x2 * xx for sin term
+	movsd	%xmm12,%xmm6				# Keep high r for cos term
+	movsd	%xmm13,%xmm7				# Keep high r for cos term
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12 	# -t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13 	# -t=r-1.0
+
+	subsd	%xmm2,%xmm4				# sin - 0.5 * x2 *xx
+	subsd	%xmm3,%xmm5				# sin - 0.5 * x2 *xx
+
+	movhlps	%xmm0,%xmm10				# move high x for x*xx for cos term
+	movhlps	%xmm1,%xmm11				# move high x for x*xx for cos term
+
+	mulsd	p_temp+8(%rsp),%xmm10		# x * xx
+	mulsd	p_temp1+8(%rsp),%xmm11		# x * xx
+
+	movsd	%xmm12,%xmm2				# move -t for cos term
+	movsd	%xmm13,%xmm3				# move -t for cos term
+
+	addsd	.L__real_3ff0000000000000(%rip),%xmm12 	# 1+(-t)
+	addsd	.L__real_3ff0000000000000(%rip),%xmm13	# 1+(-t)
+	addsd	p_temp(%rsp),%xmm4			# sin+xx
+	addsd	p_temp1(%rsp),%xmm5			# sin+xx
+	subsd	%xmm6,%xmm12				# (1-t) - r
+	subsd	%xmm7,%xmm13				# (1-t) - r
+	subsd	%xmm10,%xmm12				# ((1 + (-t)) - r) - x*xx
+	subsd	%xmm11,%xmm13				# ((1 + (-t)) - r) - x*xx
+	addsd	%xmm0,%xmm4				# sin + x
+	addsd	%xmm1,%xmm5				# sin + x
+	addsd   %xmm12,%xmm8				# cos+((1-t)-r - x*xx)
+	addsd   %xmm13,%xmm9				# cos+((1-t)-r - x*xx)
+	subsd   %xmm2,%xmm8				# cos+t
+	subsd   %xmm3,%xmm9				# cos+t
+
+	movlhps	%xmm8,%xmm4
+	movlhps	%xmm9,%xmm5
+	jmp 	.L__vrd4_cos_cleanup
+
+.align 16
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lsincos_cossin_piby4:					# changed from sincos_sincos
+							# xmm1 is cossin and xmm0 is sincos
+
+	movapd	 %xmm6,p_temp(%rsp)		# Store rr
+	movapd	 %xmm7,p_temp1(%rsp)		# Store rr
+	movapd	 %xmm1,p_temp3(%rsp)		# Store r for the sincos term
+
+	movapd	.Lsincosarray+0x50(%rip),%xmm4		# s6
+	movapd	.Lcossinarray+0x50(%rip),%xmm5		# s6
+	movdqa	.Lsincosarray+0x20(%rip),%xmm8		# s3
+	movdqa	.Lcossinarray+0x20(%rip),%xmm9		# s3
+
+	movapd	%xmm2,%xmm10				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+
+	mulpd	%xmm2,%xmm4				# x2s6
+	mulpd	%xmm3,%xmm5				# x2s6
+	mulpd	%xmm2,%xmm8				# x2s3
+	mulpd	%xmm3,%xmm9				# x2s3
+
+	mulpd	%xmm2,%xmm10				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lsincosarray+0x40(%rip),%xmm4		# s5+x2s6
+	addpd	.Lcossinarray+0x40(%rip),%xmm5		# s5+x2s6
+	addpd	.Lsincosarray+0x10(%rip),%xmm8		# s2+x2s3
+	addpd	.Lcossinarray+0x10(%rip),%xmm9		# s2+x2s3
+
+	movapd	%xmm2,%xmm12				# move x2 for x6
+	movapd	%xmm3,%xmm13				# move x2 for x6
+
+	mulpd	%xmm2,%xmm4				# x2(s5+x2s6)
+	mulpd	%xmm3,%xmm5				# x2(s5+x2s6)
+	mulpd	%xmm2,%xmm8				# x2(s2+x2s3)
+	mulpd	%xmm3,%xmm9				# x2(s2+x2s3)
+
+	mulpd	%xmm10,%xmm12				# x6
+	mulpd	%xmm11,%xmm13				# x6
+
+	addpd	.Lsincosarray+0x30(%rip),%xmm4		# s4+x2(s5+x2s6)
+	addpd	.Lcossinarray+0x30(%rip),%xmm5		# s4+x2(s5+x2s6)
+	addpd	.Lsincosarray(%rip),%xmm8		# s1+x2(s2+x2s3)
+	addpd	.Lcossinarray(%rip),%xmm9		# s1+x2(s2+x2s3)
+
+	movhlps	%xmm10,%xmm10				# move high x4 for cos term
+
+	mulpd	%xmm12,%xmm4				# x6(s4+x2(s5+x2s6))
+	mulpd	%xmm13,%xmm5				# x6(s4+x2(s5+x2s6))
+
+	movsd	%xmm2,%xmm6				# move low x2 for x3 for sin term  (cossin)
+	movhlps	%xmm3,%xmm7				# move high x2 for x3 for sin term (sincos)
+
+	mulsd	%xmm0,%xmm6				# get low x3 for sin term
+	mulsd	p_temp3+8(%rsp),%xmm7		# get high x3 for sin term
+
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for sin and cos terms
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for sin and cos terms
+
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm2,%xmm12				# move high r for cos (cossin)
+	movhlps	%xmm3,%xmm13				# move high 0.5*x2 for sin term (sincos)
+
+	movhlps	%xmm4,%xmm8				# xmm8 = cos , xmm4 = sin	(cossin)
+	movhlps	%xmm5,%xmm9				# xmm9 = sin , xmm5 = cos	(sincos)
+
+	mulsd	%xmm6,%xmm4				# sin *x3
+	mulsd	%xmm11,%xmm5				# cos *x4
+	mulsd	%xmm10,%xmm8				# cos *x4
+	mulsd	%xmm7,%xmm9				# sin *x3
+
+	mulsd	p_temp(%rsp),%xmm2		# low  0.5 * x2 * xx for sin term (cossin)
+	mulsd	p_temp1+8(%rsp),%xmm13		# high 0.5 * x2 * xx for sin term (sincos)
+
+	movsd	%xmm12,%xmm6				# Keep high r for cos term
+	movsd	%xmm3,%xmm7				# Keep low r for cos term
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12 	# -t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm3 	# -t=r-1.0
+
+	subsd	%xmm2,%xmm4				# sin - 0.5 * x2 *xx	(cossin)
+	subsd	%xmm13,%xmm9				# sin - 0.5 * x2 *xx	(sincos)
+
+	movhlps	%xmm0,%xmm10				# move high x for x*xx for cos term (cossin)
+	movhlps	%xmm1,%xmm11				# move high x for x for sin term    (sincos)
+
+	mulsd	p_temp+8(%rsp),%xmm10		# x * xx
+	mulsd	p_temp1(%rsp),%xmm1		# x * xx
+
+	movsd	%xmm12,%xmm2				# move -t for cos term
+	movsd	%xmm3,%xmm13				# move -t for cos term
+
+	addsd	.L__real_3ff0000000000000(%rip),%xmm12	# 1+(-t)
+	addsd	.L__real_3ff0000000000000(%rip),%xmm3 # 1+(-t)
+
+	addsd	p_temp(%rsp),%xmm4		# sin+xx	+
+	addsd	p_temp1+8(%rsp),%xmm9		# sin+xx	+
+
+	subsd	%xmm6,%xmm12				# (1-t) - r
+	subsd	%xmm7,%xmm3				# (1-t) - r
+
+	subsd	%xmm10,%xmm12				# ((1 + (-t)) - r) - x*xx
+	subsd	%xmm1,%xmm3				# ((1 + (-t)) - r) - x*xx
+
+	addsd	%xmm0,%xmm4				# sin + x	+
+	addsd	%xmm11,%xmm9				# sin + x	+
+
+	addsd   %xmm12,%xmm8				# cos+((1-t)-r - x*xx)
+	addsd   %xmm3,%xmm5				# cos+((1-t)-r - x*xx)
+
+	subsd   %xmm2,%xmm8				# cos+t
+	subsd   %xmm13,%xmm5				# cos+t
+
+	movlhps	%xmm8,%xmm4				# cossin
+	movlhps	%xmm9,%xmm5				# sincos
+
+	jmp	.L__vrd4_cos_cleanup
+
+.align 16
+.Lsincos_sincos_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	movapd	 %xmm6,p_temp(%rsp)		# Store rr
+	movapd	 %xmm7,p_temp1(%rsp)		# Store rr
+	movapd	 %xmm0,p_temp2(%rsp)		# Store r
+	movapd	 %xmm1,p_temp3(%rsp)		# Store r
+
+
+	movapd	.Lcossinarray+0x50(%rip),%xmm4		# s6
+	movapd	.Lcossinarray+0x50(%rip),%xmm5		# s6
+	movdqa	.Lcossinarray+0x20(%rip),%xmm8		# s3
+	movdqa	.Lcossinarray+0x20(%rip),%xmm9		# s3
+
+	movapd	%xmm2,%xmm10				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+
+	mulpd	%xmm2,%xmm4				# x2s6
+	mulpd	%xmm3,%xmm5				# x2s6
+	mulpd	%xmm2,%xmm8				# x2s3
+	mulpd	%xmm3,%xmm9				# x2s3
+
+	mulpd	%xmm2,%xmm10				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lcossinarray+0x40(%rip),%xmm4		# s5+x2s6
+	addpd	.Lcossinarray+0x40(%rip),%xmm5		# s5+x2s6
+	addpd	.Lcossinarray+0x10(%rip),%xmm8		# s2+x2s3
+	addpd	.Lcossinarray+0x10(%rip),%xmm9		# s2+x2s3
+
+	movapd	%xmm2,%xmm12				# move x2 for x6
+	movapd	%xmm3,%xmm13				# move x2 for x6
+
+	mulpd	%xmm2,%xmm4				# x2(s5+x2s6)
+	mulpd	%xmm3,%xmm5				# x2(s5+x2s6)
+	mulpd	%xmm2,%xmm8				# x2(s2+x2s3)
+	mulpd	%xmm3,%xmm9				# x2(s2+x2s3)
+
+	mulpd	%xmm10,%xmm12				# x6
+	mulpd	%xmm11,%xmm13				# x6
+
+	addpd	.Lcossinarray+0x30(%rip),%xmm4		# s4+x2(s5+x2s6)
+	addpd	.Lcossinarray+0x30(%rip),%xmm5		# s4+x2(s5+x2s6)
+	addpd	.Lcossinarray(%rip),%xmm8		# s1+x2(s2+x2s3)
+	addpd	.Lcossinarray(%rip),%xmm9		# s1+x2(s2+x2s3)
+
+	mulpd	%xmm12,%xmm4				# x6(s4+x2(s5+x2s6))
+	mulpd	%xmm13,%xmm5				# x6(s4+x2(s5+x2s6))
+
+	movhlps	%xmm2,%xmm6				# move low x2 for x3 for sin term
+	movhlps	%xmm3,%xmm7				# move low x2 for x3 for sin term
+	mulsd	p_temp2+8(%rsp),%xmm6		# get low x3 for sin term
+	mulsd	p_temp3+8(%rsp),%xmm7		# get low x3 for sin term
+
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for sin and cos terms
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for sin and cos terms
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm2,%xmm12				# move high 0.5*x2 for sin term
+	movhlps	%xmm3,%xmm13				# move high 0.5*x2 for sin term
+							# Reverse 12 and 2
+
+	movhlps	%xmm4,%xmm8				# xmm8 = sin , xmm4 = cos
+	movhlps	%xmm5,%xmm9				# xmm9 = sin , xmm5 = cos
+
+	mulsd	%xmm6,%xmm8				# sin *x3
+	mulsd	%xmm7,%xmm9				# sin *x3
+	mulsd	%xmm10,%xmm4				# cos *x4
+	mulsd	%xmm11,%xmm5				# cos *x4
+
+	mulsd	p_temp+8(%rsp),%xmm12		# 0.5 * x2 * xx for sin term
+	mulsd	p_temp1+8(%rsp),%xmm13		# 0.5 * x2 * xx for sin term
+	movsd	%xmm2,%xmm6				# Keep high r for cos term
+	movsd	%xmm3,%xmm7				# Keep high r for cos term
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm2 	# -t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm3 	# -t=r-1.0
+
+	subsd	%xmm12,%xmm8				# sin - 0.5 * x2 *xx
+	subsd	%xmm13,%xmm9				# sin - 0.5 * x2 *xx
+
+	movhlps	%xmm0,%xmm10				# move high x for x for sin term
+	movhlps	%xmm1,%xmm11				# move high x for x for sin term
+							# Reverse 10 and 0
+
+	mulsd	p_temp(%rsp),%xmm0		# x * xx
+	mulsd	p_temp1(%rsp),%xmm1		# x * xx
+
+	movsd	%xmm2,%xmm12				# move -t for cos term
+	movsd	%xmm3,%xmm13				# move -t for cos term
+
+	addsd	.L__real_3ff0000000000000(%rip),%xmm2 	# 1+(-t)
+	addsd	.L__real_3ff0000000000000(%rip),%xmm3 	# 1+(-t)
+	addsd	p_temp+8(%rsp),%xmm8			# sin+xx
+	addsd	p_temp1+8(%rsp),%xmm9			# sin+xx
+
+	subsd	%xmm6,%xmm2				# (1-t) - r
+	subsd	%xmm7,%xmm3				# (1-t) - r
+
+	subsd	%xmm0,%xmm2				# ((1 + (-t)) - r) - x*xx
+	subsd	%xmm1,%xmm3				# ((1 + (-t)) - r) - x*xx
+
+	addsd	%xmm10,%xmm8				# sin + x
+	addsd	%xmm11,%xmm9				# sin + x
+
+	addsd   %xmm2,%xmm4				# cos+((1-t)-r - x*xx)
+	addsd   %xmm3,%xmm5				# cos+((1-t)-r - x*xx)
+
+	subsd   %xmm12,%xmm4				# cos+t
+	subsd   %xmm13,%xmm5				# cos+t
+
+	movlhps	%xmm8,%xmm4
+	movlhps	%xmm9,%xmm5
+	jmp 	.L__vrd4_cos_cleanup
+
+.align 16
+.Lcossin_sincos_piby4:					# changed from sincos_sincos
+							# xmm1 is cossin and xmm0 is sincos
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	movapd	 %xmm6,p_temp(%rsp)		# Store rr
+	movapd	 %xmm7,p_temp1(%rsp)		# Store rr
+	movapd	 %xmm0,p_temp2(%rsp)		# Store r
+
+
+	movapd	.Lcossinarray+0x50(%rip),%xmm4		# s6
+	movapd	.Lsincosarray+0x50(%rip),%xmm5		# s6
+	movdqa	.Lcossinarray+0x20(%rip),%xmm8		# s3
+	movdqa	.Lsincosarray+0x20(%rip),%xmm9		# s3
+
+	movapd	%xmm2,%xmm10				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+
+	mulpd	%xmm2,%xmm4				# x2s6
+	mulpd	%xmm3,%xmm5				# x2s6
+	mulpd	%xmm2,%xmm8				# x2s3
+	mulpd	%xmm3,%xmm9				# x2s3
+
+	mulpd	%xmm2,%xmm10				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lcossinarray+0x40(%rip),%xmm4		# s5+x2s6
+	addpd	.Lsincosarray+0x40(%rip),%xmm5		# s5+x2s6
+	addpd	.Lcossinarray+0x10(%rip),%xmm8		# s2+x2s3
+	addpd	.Lsincosarray+0x10(%rip),%xmm9		# s2+x2s3
+
+	movapd	%xmm2,%xmm12				# move x2 for x6
+	movapd	%xmm3,%xmm13				# move x2 for x6
+
+	mulpd	%xmm2,%xmm4				# x2(s5+x2s6)
+	mulpd	%xmm3,%xmm5				# x2(s5+x2s6)
+	mulpd	%xmm2,%xmm8				# x2(s2+x2s3)
+	mulpd	%xmm3,%xmm9				# x2(s2+x2s3)
+
+	mulpd	%xmm10,%xmm12				# x6
+	mulpd	%xmm11,%xmm13				# x6
+
+	addpd	.Lcossinarray+0x30(%rip),%xmm4		# s4+x2(s5+x2s6)
+	addpd	.Lsincosarray+0x30(%rip),%xmm5		# s4+x2(s5+x2s6)
+	addpd	.Lcossinarray(%rip),%xmm8		# s1+x2(s2+x2s3)
+	addpd	.Lsincosarray(%rip),%xmm9		# s1+x2(s2+x2s3)
+
+	movhlps	%xmm11,%xmm11				# move high x4 for cos term	+
+
+	mulpd	%xmm12,%xmm4				# x6(s4+x2(s5+x2s6))
+	mulpd	%xmm13,%xmm5				# x6(s4+x2(s5+x2s6))
+
+	movhlps	%xmm2,%xmm6				# move low x2 for x3 for sin term
+	movsd	%xmm3,%xmm7				# move low x2 for x3 for sin term   	+
+	mulsd	p_temp2+8(%rsp),%xmm6		# get low x3 for sin term
+	mulsd	%xmm1,%xmm7				# get low x3 for sin term		+
+
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for sin and cos terms
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for sin and cos terms
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm2,%xmm12				# move high 0.5*x2 for sin term
+	movhlps	%xmm3,%xmm13				# move high r for cos
+
+	movhlps	%xmm4,%xmm8				# xmm8 = sin , xmm4 = cos
+	movhlps	%xmm5,%xmm9				# xmm9 = cos , xmm5 = sin
+
+	mulsd	%xmm6,%xmm8				# sin *x3
+	mulsd	%xmm11,%xmm9				# cos *x4
+	mulsd	%xmm10,%xmm4				# cos *x4
+	mulsd	%xmm7,%xmm5				# sin *x3
+
+	mulsd	p_temp+8(%rsp),%xmm12		# 0.5 * x2 * xx for sin term
+	mulsd	p_temp1(%rsp),%xmm3		# 0.5 * x2 * xx for sin term
+
+	movsd	%xmm2,%xmm6				# Keep high r for cos term
+	movsd	%xmm13,%xmm7				# Keep high r for cos term
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm2 	# -t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13 	# -t=r-1.0
+
+	subsd	%xmm12,%xmm8				# sin - 0.5 * x2 *xx
+	subsd	%xmm3,%xmm5				# sin - 0.5 * x2 *xx
+
+	movhlps	%xmm0,%xmm10				# move high x for x for sin term
+	movhlps	%xmm1,%xmm11				# move high x for x*xx for cos term
+
+	mulsd	p_temp(%rsp),%xmm0		# x * xx
+	mulsd	p_temp1+8(%rsp),%xmm11		# x * xx
+
+	movsd	%xmm2,%xmm12				# move -t for cos term
+	movsd	%xmm13,%xmm3				# move -t for cos term
+
+	addsd	.L__real_3ff0000000000000(%rip),%xmm2 	# 1+(-t)
+	addsd	.L__real_3ff0000000000000(%rip),%xmm13 	# 1+(-t)
+
+	addsd	p_temp+8(%rsp),%xmm8		# sin+xx
+	addsd	p_temp1(%rsp),%xmm5		# sin+xx
+
+	subsd	%xmm6,%xmm2				# (1-t) - r
+	subsd	%xmm7,%xmm13				# (1-t) - r
+
+	subsd	%xmm0,%xmm2				# ((1 + (-t)) - r) - x*xx
+	subsd	%xmm11,%xmm13				# ((1 + (-t)) - r) - x*xx
+
+
+	addsd	%xmm10,%xmm8				# sin + x
+	addsd	%xmm1,%xmm5				# sin + x
+
+	addsd   %xmm2,%xmm4				# cos+((1-t)-r - x*xx)
+	addsd   %xmm13,%xmm9				# cos+((1-t)-r - x*xx)
+
+	subsd   %xmm12,%xmm4				# cos+t
+	subsd   %xmm3,%xmm9				# cos+t
+
+	movlhps	%xmm8,%xmm4
+	movlhps	%xmm9,%xmm5
+	jmp 	.L__vrd4_cos_cleanup
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcoscos_sinsin_piby4:
+
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lsinarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lcosarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lsinarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lcosarray+0x20(%rip),%xmm9			# c3
+
+	movapd	 %xmm2,p_temp2(%rsp)			# store x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11	# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+	movapd	 %xmm11,p_temp3(%rsp)			# store r
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	mulpd	%xmm2,%xmm10					# x4
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0
+
+	movapd	%xmm2,%xmm12					# copy of x2 for 0.5*x2
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lsinarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lcosarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lsinarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lcosarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm11	# 1 + (-t)
+
+	mulpd	%xmm2,%xmm10					# x6
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm12	# 0.5 *x2
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lsinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lcosarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm10,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm0,%xmm2					# x3 recalculate
+	mulpd	%xmm3,%xmm3					# x4 recalculate
+
+	movapd   p_temp3(%rsp),%xmm13			# r
+
+	mulpd	%xmm6,%xmm12					# 0.5 * x2 *xx
+	mulpd	%xmm1,%xmm7					# x * xx
+
+	subpd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm3,%xmm5					# x4 * zc
+
+	subpd	%xmm12,%xmm4					# -0.5 * x2 *xx
+	subpd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	addpd	%xmm6,%xmm4					# x3 * zs +xx
+	addpd   %xmm11,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm13	# t relaculate, -t = r-1
+	addpd	%xmm0,%xmm4					# +x
+	subpd   %xmm13,%xmm5					# + t
+
+	jmp 	.L__vrd4_cos_cleanup
+
+.align 16
+.Lsinsin_coscos_piby4:
+
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lcosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lsinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lcosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lsinarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10	# r = 0.5 *x2
+	movapd	 %xmm3,p_temp3(%rsp)			# store x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+	movapd	 %xmm10,p_temp2(%rsp)			# store r
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0
+	mulpd	%xmm3,%xmm11					# x4
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for 0.5*x2
+
+	addpd	.Lcosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsinarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lcosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t)
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm11					# x6
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm13	# 0.5 *x2
+
+	addpd	.Lcosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lsinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm11,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zs
+
+	mulpd	%xmm2,%xmm2					# x4 recalculate
+	mulpd	%xmm1,%xmm3					# x3 recalculate
+
+	movapd   p_temp2(%rsp),%xmm12			# r
+
+	mulpd	%xmm0,%xmm6					# x * xx
+	mulpd	%xmm7,%xmm13					# 0.5 * x2 *xx
+	subpd   %xmm12,%xmm10					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x3 * zs
+
+	subpd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx;;;;;;;;;;;;;;;;;;;;;
+	subpd	%xmm13,%xmm5					# -0.5 * x2 *xx
+	addpd   %xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addpd	%xmm7,%xmm5					# +xx
+	subpd	.L__real_3ff0000000000000(%rip),%xmm12	# t relaculate, -t = r-1
+	addpd	%xmm1,%xmm5					# +x
+	subpd   %xmm12,%xmm4					# + t
+
+	jmp 	.L__vrd4_cos_cleanup
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcoscos_cossin_piby4:				#Derive from cossin_coscos
+	movapd	%xmm2,%xmm10					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lsincosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lcosarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lsincosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lcosarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# r
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+	movapd	 %xmm6,p_temp(%rsp)			# rr
+	movhlps	%xmm10,%xmm10					# get upper r for t for cos
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0  for cos
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lsincosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lcosarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lsincosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lcosarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addsd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t)
+	addpd   .L__real_3ff0000000000000(%rip),%xmm11	# 1 + (-t)
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lsincosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsincosarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lcosarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zc
+
+	movsd	%xmm0,%xmm8					# lower x for sin
+	mulsd	%xmm2,%xmm8					# lower x3 for sin
+
+	mulpd	%xmm2,%xmm2					# x4
+	mulpd	%xmm3,%xmm3					# upper x4 for cos
+	movsd	%xmm8,%xmm2					# lower x3 for sin
+
+	movsd	 %xmm6,%xmm9					# lower xx
+								# note using odd reg
+
+	movlpd   p_temp2+8(%rsp),%xmm12		# upper r for cos term
+	movapd   p_temp3(%rsp),%xmm13			# r
+
+	mulpd	%xmm0,%xmm6					# x * xx for upper cos term
+	mulpd	%xmm1,%xmm7					# x * xx
+	movhlps	%xmm6,%xmm6
+	mulsd	p_temp2(%rsp),%xmm9 			# xx * 0.5*x2 for sin term
+
+	subsd   %xmm12,%xmm10					# (1 + (-t)) - r
+	subpd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x4 * zc
+								# x3 * zs
+
+	movhlps	%xmm4,%xmm8					# xmm8= cos, xmm4= sin
+
+	subsd	%xmm9,%xmm4					# x3zs - 0.5*x2*xx
+
+	subsd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx
+	subpd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	addsd   %xmm10,%xmm8					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addpd   %xmm11,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp(%rsp),%xmm4			# +xx
+
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12	# -t = r-1
+	subpd	.L__real_3ff0000000000000(%rip),%xmm13	# -t = r-1
+
+	subsd   %xmm12,%xmm8					# + t
+	addsd	%xmm0,%xmm4					# +x
+	subpd   %xmm13,%xmm5					# + t
+
+	movlhps	%xmm8,%xmm4
+
+	jmp	.L__vrd4_cos_cleanup
+
+.align 16
+.Lcoscos_sincos_piby4:		#Derive from sincos_coscos
+	movapd	%xmm2,%xmm10					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lcossinarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lcosarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lcossinarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lcosarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10	# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11	# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# r
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+	movapd	 %xmm6,p_temp(%rsp)			# rr
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0 for cos
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lcossinarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lcosarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lcossinarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lcosarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addsd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t) for cos
+	addpd   .L__real_3ff0000000000000(%rip),%xmm11	# 1 + (-t)
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lcossinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lcossinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lcosarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zszc
+	addpd	%xmm9,%xmm5					# z
+
+	mulpd	%xmm0,%xmm2					# upper x3 for sin
+	mulsd	%xmm0,%xmm2					# lower x4 for cos
+	mulpd	%xmm3,%xmm3					# x4
+
+	movhlps	%xmm6,%xmm9					# upper xx for sin term
+								# note using odd reg
+
+	movlpd  p_temp2(%rsp),%xmm12			# lower r for cos term
+	movapd  p_temp3(%rsp),%xmm13			# r
+
+
+	mulpd	%xmm0,%xmm6					# x * xx for lower cos term
+	mulpd	%xmm1,%xmm7					# x * xx
+
+	mulsd	p_temp2+8(%rsp),%xmm9 			# xx * 0.5*x2 for upper sin term
+
+	subsd   %xmm12,%xmm10					# (1 + (-t)) - r
+	subpd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# lower=x4 * zc
+								# upper=x3 * zs
+	mulpd	%xmm3,%xmm5
+								# x4 * zc
+
+	movhlps	%xmm4,%xmm8					# xmm8= sin, xmm4= cos
+	subsd	%xmm9,%xmm8					# x3zs - 0.5*x2*xx
+
+
+	subsd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx
+	subpd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	addsd   %xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addpd   %xmm11,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp+8(%rsp),%xmm8			# +xx
+
+	movhlps	%xmm0,%xmm0					# upper x for sin
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12	# -t = r-1
+	subpd	.L__real_3ff0000000000000(%rip),%xmm13	# -t = r-1
+
+	subsd   %xmm12,%xmm4					# + t
+	subpd   %xmm13,%xmm5					# + t
+	addsd	%xmm0,%xmm8					# +x
+
+	movlhps	%xmm8,%xmm4
+
+	jmp 	.L__vrd4_cos_cleanup
+
+.align 16
+.Lcossin_coscos_piby4:
+	movapd	%xmm2,%xmm10					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lcosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lsincosarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lcosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lsincosarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# r
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+	movapd	 %xmm7,p_temp1(%rsp)			# rr
+	movhlps	%xmm11,%xmm11					# get upper r for t for cos
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0 for cos
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lcosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsincosarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lcosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsincosarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm10		# 1 + (-t)	;trash t
+	addsd   .L__real_3ff0000000000000(%rip),%xmm11		# 1 + (-t)	;trash t
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lcosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsincosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lsincosarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zcs
+
+	movsd	%xmm1,%xmm9					# lower x for sin
+	mulsd	%xmm3,%xmm9					# lower x3 for sin
+
+	mulpd	%xmm2,%xmm2					# x4
+	mulpd	%xmm3,%xmm3					# upper x4 for cos
+	movsd	%xmm9,%xmm3					# lower x3 for sin
+
+	movsd	 %xmm7,%xmm8					# lower xx
+								# note using even reg
+
+	movapd   p_temp2(%rsp),%xmm12			# r
+	movlpd   p_temp3+8(%rsp),%xmm13		# upper r for cos term
+
+	mulpd	%xmm0,%xmm6					# x * xx
+	mulpd	%xmm1,%xmm7					# x * xx for upper cos term
+	movhlps	%xmm7,%xmm7
+	mulsd	p_temp3(%rsp),%xmm8 			# xx * 0.5*x2 for sin term
+
+	subpd   %xmm12,%xmm10					# (1 + (-t)) - r
+	subsd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x4 * zc
+								# x3 * zs
+
+	movhlps	%xmm5,%xmm9					# xmm9= cos, xmm5= sin
+
+	subsd	%xmm8,%xmm5					# x3zs - 0.5*x2*xx
+
+	subpd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx
+	subsd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	addpd   %xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd   %xmm11,%xmm9					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp1(%rsp),%xmm5			# +xx
+
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm12		# t relaculate, -t = r-1
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13		# t relaculate, -t = r-1
+
+	subpd   %xmm12,%xmm4					# + t
+	subsd   %xmm13,%xmm9					# + t
+	addsd	%xmm1,%xmm5					# +x
+
+	movlhps	%xmm9,%xmm5
+
+	jmp 	.L__vrd4_cos_cleanup
+
+.align 16
+.Lcossin_sinsin_piby4:		# Derived from sincos_sinsin
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lsinarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lsincosarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lsinarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lsincosarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+	movapd	 %xmm7,p_temp1(%rsp)			# rr
+
+	movhlps	%xmm11,%xmm11
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0 for cos
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lsinarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsincosarray+0x40(%rip),%xmm5		# c5+x2c6
+	addpd	.Lsinarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsincosarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	mulpd	%xmm6,%xmm10					# 0.5*x2*xx
+	addsd   .L__real_3ff0000000000000(%rip),%xmm11	# 1 + (-t) for cos
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lsinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsincosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lsincosarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zczs
+
+	movsd	%xmm3,%xmm12
+	mulsd	%xmm1,%xmm12					# low x3 for sin
+
+	mulpd	%xmm0,%xmm2					# x3
+	mulpd	%xmm3,%xmm3					# high x4 for cos
+	movsd	%xmm12,%xmm3					# low x3 for sin
+
+	movhlps	%xmm1,%xmm8					# upper x for cos term
+								# note using even reg
+	movlpd  p_temp3+8(%rsp),%xmm13			# upper r for cos term
+
+	mulsd	p_temp1+8(%rsp),%xmm8			# x * xx for upper cos term
+
+	mulsd	p_temp3(%rsp),%xmm7 			# xx * 0.5*x2 for lower sin term
+
+	subsd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm3,%xmm5					# lower=x4 * zc
+								# upper=x3 * zs
+
+	movhlps	%xmm5,%xmm9					# xmm9= cos, xmm5= sin
+
+	subsd	%xmm7,%xmm5					# x3zs - 0.5*x2*xx
+
+	subsd   %xmm8,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	subpd	%xmm10,%xmm4					# x3*zs - 0.5*x2*xx
+	addsd   %xmm11,%xmm9					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp1(%rsp),%xmm5			# +xx
+
+	addpd	%xmm6,%xmm4					# +xx
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13	# -t = r-1
+
+
+	addsd	%xmm1,%xmm5					# +x
+	addpd	%xmm0,%xmm4					# +x
+	subsd   %xmm13,%xmm9					# + t
+
+	movlhps	%xmm9,%xmm5
+
+	jmp 	.L__vrd4_cos_cleanup
+
+.align 16
+.Lsincos_coscos_piby4:
+	movapd	%xmm2,%xmm10					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lcosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lcossinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lcosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lcossinarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# r
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+	movapd	 %xmm7,p_temp1(%rsp)			# rr
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0 for cos
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lcosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lcossinarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lcosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lcossinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t)
+	addsd   .L__real_3ff0000000000000(%rip),%xmm11	# 1 + (-t) for cos
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lcosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcossinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lcossinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zszc
+
+	mulpd	%xmm2,%xmm2					# x4
+	mulpd	%xmm1,%xmm3					# upper x3 for sin
+	mulsd	%xmm1,%xmm3					# lower x4 for cos
+
+	movhlps	%xmm7,%xmm8					# upper xx for sin term
+								# note using even reg
+
+	movapd  p_temp2(%rsp),%xmm12			# r
+	movlpd  p_temp3(%rsp),%xmm13			# lower r for cos term
+
+	mulpd	%xmm0,%xmm6					# x * xx
+	mulpd	%xmm1,%xmm7					# x * xx for lower cos term
+
+	mulsd	p_temp3+8(%rsp),%xmm8 			# xx * 0.5*x2 for upper sin term
+
+	subpd   %xmm12,%xmm10					# (1 + (-t)) - r
+	subsd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# lower=x4 * zc
+								# upper=x3 * zs
+
+	movhlps	%xmm5,%xmm9					# xmm9= sin, xmm5= cos
+
+	subsd	%xmm8,%xmm9					# x3zs - 0.5*x2*xx
+
+	subpd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx
+	subsd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	addpd   %xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd   %xmm11,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp1+8(%rsp),%xmm9			# +xx
+
+	movhlps	%xmm1,%xmm1					# upper x for sin
+	subpd	.L__real_3ff0000000000000(%rip),%xmm12	# -t = r-1
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13	# -t = r-1
+
+	subpd   %xmm12,%xmm4					# + t
+	subsd   %xmm13,%xmm5					# + t
+	addsd	%xmm1,%xmm9					# +x
+
+	movlhps	%xmm9,%xmm5
+
+	jmp 	.L__vrd4_cos_cleanup
+
+
+.align 16
+.Lsincos_sinsin_piby4:		# Derived from sincos_coscos
+	movapd	%xmm2,%xmm10					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lsinarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lcossinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lsinarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lcossinarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+	movapd	 %xmm7,p_temp1(%rsp)			# rr
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0 for cos
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lsinarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lcossinarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lsinarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lcossinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	mulpd	%xmm6,%xmm10					# 0.5x2*xx
+	addsd   .L__real_3ff0000000000000(%rip),%xmm11	# 1 + (-t) for cos
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lsinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcossinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lcossinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zszc
+
+	mulpd	%xmm0,%xmm2					# x3
+	mulpd	%xmm1,%xmm3					# upper x3 for sin
+	mulsd	%xmm1,%xmm3					# lower x4 for cos
+
+	movhlps	%xmm7,%xmm8					# upper xx for sin term
+								# note using even reg
+
+	movlpd  p_temp3(%rsp),%xmm13			# lower r for cos term
+
+	mulpd	%xmm1,%xmm7					# x * xx for lower cos term
+
+	mulsd	p_temp3+8(%rsp),%xmm8 			# xx * 0.5*x2 for upper sin term
+
+	subsd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm3,%xmm5					# lower=x4 * zc
+								# upper=x3 * zs
+
+	movhlps	%xmm5,%xmm9					# xmm9= sin, xmm5= cos
+
+	subsd	%xmm8,%xmm9					# x3zs - 0.5*x2*xx
+
+	subsd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	subpd	%xmm10,%xmm4					# x3*zs - 0.5*x2*xx
+	addsd   %xmm11,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp1+8(%rsp),%xmm9			# +xx
+
+	movhlps	%xmm1,%xmm1					# upper x for sin
+	addpd	%xmm6,%xmm4					# +xx
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13	# -t = r-1
+
+	addsd	%xmm1,%xmm9					# +x
+	addpd	%xmm0,%xmm4					# +x
+	subsd   %xmm13,%xmm5					# + t
+
+	movlhps	%xmm9,%xmm5
+
+	jmp 	.L__vrd4_cos_cleanup
+
+
+.align 16
+.Lsinsin_cossin_piby4:		# Derived from sincos_sinsin
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lsincosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lsinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lsincosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lsinarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10	# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11	# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# x2
+	movapd	 %xmm6,p_temp(%rsp)			# xx
+
+	movhlps	%xmm10,%xmm10
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0 for cos
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lsincosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsinarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lsincosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	mulpd	%xmm7,%xmm11					# 0.5*x2*xx
+	addsd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t) for cos
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lsincosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsincosarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lsinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zs
+
+
+	movsd	%xmm2,%xmm13
+	mulsd	%xmm0,%xmm13					# low x3 for sin
+
+	mulpd	%xmm1,%xmm3					# x3
+	mulpd	%xmm2,%xmm2					# high x4 for cos
+	movsd	%xmm13,%xmm2					# low x3 for sin
+
+
+	movhlps	%xmm0,%xmm9					# upper x for cos term								; note using even reg
+	movlpd  p_temp2+8(%rsp),%xmm12			# upper r for cos term
+	mulsd	p_temp+8(%rsp),%xmm9			# x * xx for upper cos term
+	mulsd	p_temp2(%rsp),%xmm6 			# xx * 0.5*x2 for lower sin term
+	subsd   %xmm12,%xmm10					# (1 + (-t)) - r
+	mulpd	%xmm3,%xmm5					# x3 * zs
+	mulpd	%xmm2,%xmm4					# lower=x4 * zc
+								# upper=x3 * zs
+
+	movhlps	%xmm4,%xmm8					# xmm8= cos, xmm4= sin
+	subsd	%xmm6,%xmm4					# x3zs - 0.5*x2*xx
+
+	subsd   %xmm9,%xmm10					# ((1 + (-t)) - r) - x*xx
+
+	subpd	%xmm11,%xmm5					# x3*zs - 0.5*x2*xx
+
+	addsd   %xmm10,%xmm8					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp(%rsp),%xmm4			# +xx
+
+	addpd	%xmm7,%xmm5					# +xx
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12	# -t = r-1
+
+	addsd	%xmm0,%xmm4					# +x
+	addpd	%xmm1,%xmm5					# +x
+	subsd   %xmm12,%xmm8					# + t
+	movlhps	%xmm8,%xmm4
+
+	jmp 	.L__vrd4_cos_cleanup
+
+.align 16
+.Lsinsin_sincos_piby4:		# Derived from sincos_coscos
+
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lcossinarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lsinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lcossinarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lsinarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# r
+	movapd	 %xmm6,p_temp(%rsp)			# rr
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0 for cos
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lcossinarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsinarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lcossinarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	mulpd	%xmm7,%xmm11					# 0.5x2*xx
+	addsd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t) for cos
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lcossinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lcossinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lsinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zszc
+
+	mulpd	%xmm1,%xmm3					# x3
+	mulpd	%xmm0,%xmm2					# upper x3 for sin
+	mulsd	%xmm0,%xmm2					# lower x4 for cos
+
+	movhlps	%xmm6,%xmm9					# upper xx for sin term
+								# note using even reg
+
+	movlpd  p_temp2(%rsp),%xmm12			# lower r for cos term
+
+	mulpd	%xmm0,%xmm6					# x * xx for lower cos term
+
+	mulsd	p_temp2+8(%rsp),%xmm9 			# xx * 0.5*x2 for upper sin term
+
+	subsd   %xmm12,%xmm10					# (1 + (-t)) - r
+
+	mulpd	%xmm3,%xmm5					# x3 * zs
+	mulpd	%xmm2,%xmm4					# lower=x4 * zc
+								# upper=x3 * zs
+
+	movhlps	%xmm4,%xmm8					# xmm9= sin, xmm5= cos
+
+	subsd	%xmm9,%xmm8					# x3zs - 0.5*x2*xx
+
+	subsd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx
+
+	subpd	%xmm11,%xmm5					# x3*zs - 0.5*x2*xx
+	addsd   %xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp+8(%rsp),%xmm8			# +xx
+
+	movhlps	%xmm0,%xmm0					# upper x for sin
+	addpd	%xmm7,%xmm5					# +xx
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12	# -t = r-1
+
+
+	addsd	%xmm0,%xmm8					# +x
+	addpd	%xmm1,%xmm5					# +x
+	subsd   %xmm12,%xmm4					# + t
+
+	movlhps	%xmm8,%xmm4
+
+	jmp 	.L__vrd4_cos_cleanup
+
+
+.align 16
+.Lsinsin_sinsin_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lsinarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lsinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lsinarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lsinarray+0x20(%rip),%xmm9			# c3
+
+	movapd	 %xmm2,p_temp2(%rsp)			# copy of x2
+	movapd	 %xmm3,p_temp3(%rsp)			# copy of x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	mulpd	%xmm2,%xmm10					# x4
+	mulpd	%xmm3,%xmm11					# x4
+
+	addpd	.Lsinarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsinarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lsinarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	mulpd	%xmm2,%xmm10					# x6
+	mulpd	%xmm3,%xmm11					# x6
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm2		# 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm3		# 0.5 *x2
+
+	addpd	.Lsinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lsinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm6,%xmm2					# 0.5 * x2 *xx
+	mulpd	%xmm7,%xmm3					# 0.5 * x2 *xx
+
+	mulpd	%xmm10,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm11,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zs
+
+	movapd	p_temp2(%rsp),%xmm10			# x2
+	movapd	p_temp3(%rsp),%xmm11			# x2
+
+	mulpd	%xmm0,%xmm10					# x3
+	mulpd	%xmm1,%xmm11					# x3
+
+	mulpd	%xmm10,%xmm4					# x3 * zs
+	mulpd	%xmm11,%xmm5					# x3 * zs
+
+	subpd	%xmm2,%xmm4					# -0.5 * x2 *xx
+	subpd	%xmm3,%xmm5					# -0.5 * x2 *xx
+
+	addpd	%xmm6,%xmm4					# +xx
+	addpd	%xmm7,%xmm5					# +xx
+
+	addpd	%xmm0,%xmm4					# +x
+	addpd	%xmm1,%xmm5					# +x
+
+	jmp 	.L__vrd4_cos_cleanup
diff --git a/src/gas/vrdaexp.S b/src/gas/vrdaexp.S
new file mode 100644
index 0000000..1ee640e
--- /dev/null
+++ b/src/gas/vrdaexp.S
@@ -0,0 +1,619 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrdaexp.asm
+#
+# An array implementation of the exp libm function.
+#
+# Prototype:
+#
+#    void vrda_exp(int n, double *x, double *y);
+#
+#   Computes e raised to the x power for an array of input values.
+#   Places the results into the supplied y array.
+# Does not perform error checking.   Denormal results are truncated to 0.
+#
+#
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+# define local variable storage offsets
+.equ	p_temp,0		# temporary for get/put bits operation
+.equ	p_temp1,0x10		# temporary for exponent multiply
+
+.equ	save_xa,0x020		#qword
+.equ	save_ya,0x028		#qword
+.equ	save_nv,0x030		#qword
+
+.equ	p_iter,0x038		# qword	storage for number of loop iterations
+
+.equ	p2_temp,0x40		# second temporary for get/put bits operation
+				# large enough for two vectors
+.equ	p2_temp1,0x60		# second temporary for exponent multiply
+				# large enough for two vectors
+.equ    save_rbx,0x080          #qword
+
+.equ	stack_size,0x088
+
+        .weak vrda_exp_
+        .set vrda_exp_,__vrda_exp__
+        .weak vrda_exp__
+        .set vrda_exp__,__vrda_exp__
+
+    .text
+    .align 16
+    .p2align 4,,15
+
+#x/* a FORTRAN subroutine implementation of array exp
+#**     VRDA_EXP(N,X,Y)
+# C equivalent*/
+#void vrda_exp__(int * n, double *x, double *y)
+#{
+#       vrda_exp(*n,x,y);
+#}
+.globl __vrda_exp__
+    .type   __vrda_exp__,@function
+__vrda_exp__:
+    mov         (%rdi),%edi
+
+
+        .align 16
+        .p2align 4,,15
+
+
+# parameters are passed in by gcc as:
+# edi - int n
+# rsi - double *x
+# rdx - double *y
+
+
+.globl vrda_exp
+       .type   vrda_exp,@function
+vrda_exp:
+
+	sub		$stack_size,%rsp
+        mov             %rbx,save_rbx(%rsp)
+
+# save the arguments
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+	mov		%rdx,save_ya(%rsp)	# save y_array pointer
+#ifdef INTEGER64
+        mov             %rdi,%rax
+#else
+        mov             %edi,%eax
+        mov             %rax,%rdi
+#endif
+
+	mov		%rdi,save_nv(%rsp)	# save number of values
+# see if too few values to call the main loop
+	shr		$2,%rax			# get number of iterations
+	jz		.L__vda_cleanup		# jump if only single calls
+# prepare the iteration counts
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	shl		$2,%rax
+	sub		%rax,%rdi		# compute number of extra single calls
+	mov		%rdi,save_nv(%rsp)	# save number of left over values
+
+# In this second version, process the array 4 values at a time.
+
+.L__vda_top:
+# build the input _m128d
+	movapd	.L__real_thirtytwo_by_log2(%rip),%xmm3	#
+	mov		save_xa(%rsp),%rsi	# get x_array pointer
+	movlpd	(%rsi),%xmm0
+	movhpd	8(%rsi),%xmm0
+	prefetch	64(%rsi)
+	add		$32,%rsi
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+
+# compute the exponents
+
+#      Step 1. Reduce the argument.
+#        /* Find m, z1 and z2 such that exp(x) = 2**m * (z1 + z2) */
+#    r = x * thirtytwo_by_logbaseof2;
+		movapd	%xmm3,%xmm7
+	movapd	 %xmm0,p_temp(%rsp)
+	maxpd	.L__real_C0F0000000000000(%rip),%xmm0	# protect against very large negative, non-infinite numbers
+	mulpd	%xmm0,%xmm3
+
+		movlpd	-16(%rsi),%xmm6
+		movhpd	-8(%rsi),%xmm6
+		movapd	 %xmm6,p2_temp(%rsp)
+		maxpd	.L__real_C0F0000000000000(%rip),%xmm6
+		mulpd	%xmm6,%xmm7
+
+# save x for later.
+        minpd   .L__real_40F0000000000000(%rip),%xmm3    # protect against very large, non-infinite numbers
+
+#    /* Set n = nearest integer to r */
+	cvtpd2dq	%xmm3,%xmm4
+	lea		.L__two_to_jby32_lead_table(%rip),%rdi
+	lea		.L__two_to_jby32_trail_table(%rip),%rsi
+	cvtdq2pd	%xmm4,%xmm1
+        	minpd   .L__real_40F0000000000000(%rip),%xmm7    # protect against very large, non-infinite numbers
+
+ #    r1 = x - n * logbaseof2_by_32_lead;
+	movapd	.L__real_log2_by_32_lead(%rip),%xmm2	#
+	mulpd	%xmm1,%xmm2				#
+	movq	 %xmm4,p_temp1(%rsp)
+	subpd	%xmm2,%xmm0	 			# r1 in xmm0,
+
+		cvtpd2dq	%xmm7,%xmm2
+		cvtdq2pd	%xmm2,%xmm8
+
+#    r2 =   - n * logbaseof2_by_32_trail;
+	mulpd	.L__real_log2_by_32_tail(%rip),%xmm1	# r2 in xmm1
+#    j = n & 0x0000001f;
+	mov		$0x01f,%r9
+	mov		%r9,%r8
+	mov		p_temp1(%rsp),%ecx
+	and		%ecx,%r9d
+		movq	 %xmm2,p2_temp1(%rsp)
+		movapd	.L__real_log2_by_32_lead(%rip),%xmm9
+		mulpd	%xmm8,%xmm9
+		subpd	%xmm9,%xmm6					 			# r1b in xmm6
+		mulpd	.L__real_log2_by_32_tail(%rip),%xmm8	# r2b in xmm8
+
+	mov		p_temp1+4(%rsp),%edx
+	and		%edx,%r8d
+#    f1 = two_to_jby32_lead_table[j];
+#    f2 = two_to_jby32_trail_table[j];
+
+#    *m = (n - j) / 32;
+	sub		%r9d,%ecx
+	sar		$5,%ecx					#m
+	sub		%r8d,%edx
+	sar		$5,%edx
+
+
+	movapd	%xmm0,%xmm2
+	addpd	%xmm1,%xmm2   # r = r1 + r2
+
+		mov		$0x01f,%r11
+		mov		%r11,%r10
+		mov		p2_temp1(%rsp),%ebx
+		and		%ebx,%r11d
+#      Step 2. Compute the polynomial.
+#    q = r1 + (r2 +
+#              r*r*( 5.00000000000000008883e-01 +
+#                      r*( 1.66666666665260878863e-01 +
+#                      r*( 4.16666666662260795726e-02 +
+#                      r*( 8.33336798434219616221e-03 +
+#                      r*( 1.38889490863777199667e-03 ))))));
+#    q = r + r^2/2 + r^3/6 + r^4/24 + r^5/120 + r^6/720
+	movapd	%xmm2,%xmm1
+	movapd	.L__real_3f56c1728d739765(%rip),%xmm3	# 	1/720
+	movapd	.L__real_3FC5555555548F7C(%rip),%xmm0	# 	1/6
+# deal with infinite results
+	mov		$1024,%rax
+	movsx	%ecx,%rcx
+	cmp		%rax,%rcx
+
+	mulpd	%xmm2,%xmm3				# *x
+	mulpd	%xmm2,%xmm0				# *x
+	mulpd	%xmm2,%xmm1				# x*x
+	movapd	%xmm1,%xmm4
+
+	cmovg	%rax,%rcx				## if infinite, then set rcx to multiply
+							# by infinity
+	movsx	%edx,%rdx
+	cmp		%rax,%rdx
+
+		movapd	%xmm6,%xmm9
+		addpd	%xmm8,%xmm9  #  rb = r1b + r2b
+	addpd	.L__real_3F811115B7AA905E(%rip),%xmm3	# 	+ 1/120
+	addpd	.L__real_3fe0000000000000(%rip),%xmm0	# 	+ .5
+	mulpd	%xmm1,%xmm4				# x^4
+	mulpd	%xmm2,%xmm3				# *x
+
+	cmovg	%rax,%rdx				## if infinite, then set rcx to multiply
+							# by infinity
+# deal with denormal results
+	xor		%rax,%rax
+	add		$1023,%rcx			# add bias
+
+	mulpd	%xmm1,%xmm0				# *x^2
+	addpd	.L__real_3FA5555555545D4E(%rip),%xmm3	# 	+ 1/24
+	addpd	%xmm2,%xmm0				# 	+ x
+	mulpd	%xmm4,%xmm3				# *x^4
+
+# check for infinity or nan
+	movapd	p_temp(%rsp),%xmm2
+
+	cmovs	%rax,%rcx			## if denormal, then multiply by 0
+	shl		$52,%rcx		# build 2^n
+
+		sub		%r11d,%ebx
+		movapd	%xmm9,%xmm1
+	addpd	%xmm3,%xmm0			# q = final sum
+		movapd	.L__real_3f56c1728d739765(%rip),%xmm7	# 	1/720
+		movapd	.L__real_3FC5555555548F7C(%rip),%xmm3	# 	1/6
+
+#    *z2 = f2 + ((f1 + f2) * q);
+	movlpd	(%rsi,%r9,8),%xmm5		# f2
+	movlpd	(%rsi,%r8,8),%xmm4		# f2
+	addsd	(%rdi,%r8,8),%xmm4		# f1 + f2
+	addsd	(%rdi,%r9,8),%xmm5		# f1 + f2
+		mov p2_temp1+4(%rsp),%r8d
+		and	%r8d,%r10d
+		sar	$5,%ebx			#m
+		mulpd	%xmm9,%xmm7		# *x
+		mulpd	%xmm9,%xmm3		# *x
+		mulpd	%xmm9,%xmm1		# x*x
+		sub		%r10d,%r8d
+		sar		$5,%r8d
+# check for infinity or nan
+	andpd	.L__real_infinity(%rip),%xmm2
+	cmppd	$0,.L__real_infinity(%rip),%xmm2
+	add		$1023,%rdx		# add bias
+	shufpd	$0,%xmm4,%xmm5
+		movapd	%xmm1,%xmm4
+
+	cmovs	%rax,%rdx			## if denormal, then multiply by 0
+	shl		$52,%rdx		# build 2^n
+
+	mulpd	%xmm5,%xmm0
+	mov		 %rcx,p_temp1(%rsp) # get 2^n to memory
+	mov		 %rdx,p_temp1+8(%rsp) # get 2^n to memory
+	addpd	%xmm5,%xmm0			#z = z1 + z2   done with 1,2,3,4,5
+		mov		$1024,%rax
+		movsx	%ebx,%rbx
+		cmp		%rax,%rbx
+# end of splitexp
+#        /* Scale (z1 + z2) by 2.0**m */
+#          r = scaleDouble_1(z, n);
+
+
+		cmovg	%rax,%rbx		## if infinite, then set rcx to multiply
+						# by infinity
+		movsx	%r8d,%rdx
+		cmp		%rax,%rdx
+
+	movmskpd	%xmm2,%r8d
+
+		addpd	.L__real_3F811115B7AA905E(%rip),%xmm7	# 	+ 1/120
+		addpd	.L__real_3fe0000000000000(%rip),%xmm3	# 	+ .5
+		mulpd	%xmm1,%xmm4			# x^4
+		mulpd	%xmm9,%xmm7			# *x
+		cmovg	%rax,%rdx			## if infinite, then set rcx to multiply
+
+
+		xor		%rax,%rax
+		add		$1023,%rbx		# add bias
+
+		mulpd	%xmm1,%xmm3			# *x^2
+		addpd	.L__real_3FA5555555545D4E(%rip),%xmm7	# 	+ 1/24
+		addpd	%xmm9,%xmm3			# 	+ x
+		mulpd	%xmm4,%xmm7			# *x^4
+
+		cmovs	%rax,%rbx			## if denormal, then multiply by 0
+		shl		$52,%rbx		# build 2^n
+
+#      Step 3. Reconstitute.
+
+	mulpd	p_temp1(%rsp),%xmm0	# result *= 2^n
+		addpd	%xmm7,%xmm3			# q = final sum
+
+		movlpd	(%rsi,%r11,8),%xmm5 		# f2
+		movlpd	(%rsi,%r10,8),%xmm4 		# f2
+		addsd	(%rdi,%r10,8),%xmm4		# f1 + f2
+		addsd	(%rdi,%r11,8),%xmm5		# f1 + f2
+
+		add		$1023,%rdx		# add bias
+		cmovs	%rax,%rdx			## if denormal, then multiply by 0
+		shufpd	$0,%xmm4,%xmm5
+		shl		$52,%rdx		# build 2^n
+
+		mulpd	%xmm5,%xmm3
+		mov		 %rbx,p2_temp1(%rsp) # get 2^n to memory
+		mov		 %rdx,p2_temp1+8(%rsp) # get 2^n to memory
+		addpd	%xmm5,%xmm3						#z = z1 + z2
+
+		movapd	p2_temp(%rsp),%xmm2
+		andpd	.L__real_infinity(%rip),%xmm2
+		cmppd	$0,.L__real_infinity(%rip),%xmm2
+		movmskpd	%xmm2,%ebx
+	test		$3,%r8d
+		mulpd	p2_temp1(%rsp),%xmm3	# result *= 2^n
+# we'd like to avoid a branch, and can use cmp's and and's to
+# eliminate them.  But it adds cycles for normal cases which
+# are supposed to be exceptions.  Using this branch with the
+# check above results in faster code for the normal cases.
+	jnz			.L__exp_naninf
+
+.L__vda_bottom1:
+# store the result _m128d
+	mov		save_ya(%rsp),%rdi	# get y_array pointer
+	movlpd	%xmm0,(%rdi)
+	movhpd	 %xmm0,8(%rdi)
+		test		$3,%ebx
+		jnz			.L__exp_naninf2
+
+.L__vda_bottom2:
+
+	prefetch	64(%rdi)
+	add		$32,%rdi
+	mov		%rdi,save_ya(%rsp)	# save y_array pointer
+
+# store the result _m128d
+		movlpd	%xmm3,-16(%rdi)
+		movhpd	%xmm3,-8(%rdi)
+
+	mov		p_iter(%rsp),%rax	# get number of iterations
+	sub		$1,%rax
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	jnz		.L__vda_top
+
+
+# see if we need to do any extras
+	mov		save_nv(%rsp),%rax	# get number of values
+	test	%rax,%rax
+	jnz		.L__vda_cleanup
+
+
+#
+#
+.L__final_check:
+        mov             save_rbx(%rsp),%rbx             # restore rbx
+	add		$stack_size,%rsp
+	ret
+
+# at least one of the numbers needs special treatment
+.L__exp_naninf:
+	lea		p_temp(%rsp),%rcx
+	call  .L__naninf
+	jmp		.L__vda_bottom1
+.L__exp_naninf2:
+	lea		p2_temp(%rsp),%rcx
+	mov			%ebx,%r8d
+	movapd	%xmm3,%xmm0
+	call  .L__naninf
+	movapd	%xmm0,%xmm3
+	jmp		.L__vda_bottom2
+
+# This subroutine checks a double pair for nans and infinities and
+# produces the proper result from the exceptional inputs
+# Register assumptions:
+# Inputs:
+# r8d - mask of errors
+# xmm0 - computed result vector
+# rcx - pointing to memory image of inputs
+# Outputs:
+# xmm0 - new result vector
+# %rax,rdx,,%xmm2 all modified.
+.L__naninf:
+# check the first number
+	test	$1,%r8d
+	jz		.L__check2
+
+	mov		(%rcx),%rdx
+	mov		$0x0000FFFFFFFFFFFFF,%rax
+	test	%rax,%rdx
+	jnz		.L__enan1			# jump if mantissa not zero, so it's a NaN
+# inf
+	mov		%rdx,%rax
+	rcl		$1,%rax
+	jnc		.L__r1			# exp(+inf) = inf
+	xor		%rdx,%rdx			# exp(-inf) = 0
+	jmp		.L__r1
+
+#NaN
+.L__enan1:
+	mov		$0x00008000000000000,%rax	# convert to quiet
+	or		%rax,%rdx
+.L__r1:
+	movd	%rdx,%xmm2
+	shufpd	$2,%xmm0,%xmm2
+	movsd	%xmm2,%xmm0
+# check the second number
+.L__check2:
+	test	$2,%r8d
+	jz		.L__r3
+	mov		8(%rcx),%rdx
+	mov		$0x0000FFFFFFFFFFFFF,%rax
+	test	%rax,%rdx
+	jnz		.L__enan2			# jump if mantissa not zero, so it's a NaN
+# inf
+	mov		%rdx,%rax
+	rcl		$1,%rax
+	jnc		.L__r2			# exp(+inf) = inf
+	xor		%rdx,%rdx			# exp(-inf) = 0
+	jmp		.L__r2
+
+#NaN
+.L__enan2:
+	mov		$0x00008000000000000,%rax	# convert to quiet
+	or		%rax,%rdx
+.L__r2:
+	movd	%rdx,%xmm2
+	shufpd	$0,%xmm2,%xmm0
+.L__r3:
+	ret
+
+	.align	16
+# we jump here when we have an odd number of exp calls to make at the
+# end
+#  we assume that rdx is pointing at the next x array element,
+#  r8 at the next y array element.  The number of values left is in
+#  save_nv
+.L__vda_cleanup:
+        mov             save_nv(%rsp),%rax      # get number of values
+        test            %rax,%rax               # are there any values
+        jz              .L__final_check         # exit if not
+
+	mov		save_xa(%rsp),%rsi
+	mov		save_ya(%rsp),%rdi
+# fill in a m128d with zeroes and the extra values and then make a recursive call.
+	xorpd		%xmm0,%xmm0
+	movlpd	 	%xmm0,p2_temp+8(%rsp)
+	movapd	 	%xmm0,p2_temp+16(%rsp)
+
+	mov		(%rsi),%rcx		# we know there's at least one
+	mov	 	%rcx,p2_temp(%rsp)
+	cmp		$2,%rax
+	jl		.L_vdacg
+
+	mov		8(%rsi),%rcx		# do the second value
+	mov	 	%rcx,p2_temp+8(%rsp)
+	cmp		$3,%rax
+	jl		.L_vdacg
+
+	mov		16(%rsi),%rcx		# do the third value
+	mov	 	%rcx,p2_temp+16(%rsp)
+
+.L_vdacg:
+	mov	$4,%rdi			# parameter for N
+	lea	p2_temp(%rsp),%rsi	# &x parameter
+	lea	p2_temp1(%rsp),%rdx	# &y parameter
+	call	vrda_exp@PLT			# call recursively to compute four values
+
+# now copy the results to the destination array
+	mov		save_ya(%rsp),%rdi
+	mov		save_nv(%rsp),%rax	# get number of values
+	mov	 	p2_temp1(%rsp),%rcx
+	mov		%rcx,(%rdi)		# we know there's at least one
+	cmp		$2,%rax
+	jl		.L_vdacgf
+
+	mov	 	p2_temp1+8(%rsp),%rcx
+	mov		%rcx,8(%rdi)		# do the second value
+	cmp		$3,%rax
+	jl		.L_vdacgf
+
+	mov	 	p2_temp1+16(%rsp),%rcx
+	mov		%rcx,16(%rdi)		# do the third value
+
+.L_vdacgf:
+	jmp		.L__final_check
+
+	.data
+        .align 64
+
+
+.L__real_3ff0000000000000:	.quad 0x03ff0000000000000	# 1.0
+				.quad 0x03ff0000000000000	# for alignment
+.L__real_4040000000000000:	.quad 0x04040000000000000	# 32
+				.quad 0x04040000000000000
+.L__real_40F0000000000000:      .quad 0x040F0000000000000        # 65536, to protect against really large numbers
+                                .quad 0x040F0000000000000
+.L__real_C0F0000000000000:	.quad 0x0C0F0000000000000	# -65536, to protect against really large negative numbers
+				.quad 0x0C0F0000000000000
+.L__real_3FA0000000000000:	.quad 0x03FA0000000000000	# 1/32
+				.quad 0x03FA0000000000000
+.L__real_3fe0000000000000:	.quad 0x03fe0000000000000	# 1/2
+				.quad 0x03fe0000000000000
+.L__real_infinity:		.quad 0x07ff0000000000000	#
+				.quad 0x07ff0000000000000	# for alignment
+.L__real_ninfinity:		.quad 0x0fff0000000000000	#
+				.quad 0x0fff0000000000000	# for alignment
+.L__real_thirtytwo_by_log2: 	.quad 0x040471547652b82fe	# thirtytwo_by_log2
+				.quad 0x040471547652b82fe
+.L__real_log2_by_32_lead:  	.quad 0x03f962e42fe000000	# log2_by_32_lead
+				.quad 0x03f962e42fe000000
+.L__real_log2_by_32_tail:  	.quad 0x0Bdcf473de6af278e	# -log2_by_32_tail
+				.quad 0x0Bdcf473de6af278e
+.L__real_3f56c1728d739765:	.quad 0x03f56c1728d739765	# 1.38889490863777199667e-03
+				.quad 0x03f56c1728d739765
+.L__real_3F811115B7AA905E:	.quad 0x03F811115B7AA905E	# 8.33336798434219616221e-03
+				.quad 0x03F811115B7AA905E
+.L__real_3FA5555555545D4E:	.quad 0x03FA5555555545D4E	# 4.16666666662260795726e-02
+				.quad 0x03FA5555555545D4E
+.L__real_3FC5555555548F7C:	.quad 0x03FC5555555548F7C	# 1.66666666665260878863e-01
+				.quad 0x03FC5555555548F7C
+
+
+.L__two_to_jby32_lead_table:
+	.quad	0x03ff0000000000000 # 1
+	.quad	0x03ff059b0d0000000		# 1.0219
+	.quad	0x03ff0b55860000000		# 1.04427
+	.quad	0x03ff11301d0000000		# 1.06714
+	.quad	0x03ff172b830000000		# 1.09051
+	.quad	0x03ff1d48730000000		# 1.11439
+	.quad	0x03ff2387a60000000		# 1.13879
+	.quad	0x03ff29e9df0000000		# 1.16372
+	.quad	0x03ff306fe00000000		# 1.18921
+	.quad	0x03ff371a730000000		# 1.21525
+	.quad	0x03ff3dea640000000		# 1.24186
+	.quad	0x03ff44e0860000000		# 1.26905
+	.quad	0x03ff4bfdad0000000		# 1.29684
+	.quad	0x03ff5342b50000000		# 1.32524
+	.quad	0x03ff5ab07d0000000		# 1.35426
+	.quad	0x03ff6247eb0000000		# 1.38391
+	.quad	0x03ff6a09e60000000		# 1.41421
+	.quad	0x03ff71f75e0000000		# 1.44518
+	.quad	0x03ff7a11470000000		# 1.47683
+	.quad	0x03ff8258990000000		# 1.50916
+	.quad	0x03ff8ace540000000		# 1.54221
+	.quad	0x03ff93737b0000000		# 1.57598
+	.quad	0x03ff9c49180000000		# 1.61049
+	.quad	0x03ffa5503b0000000		# 1.64576
+	.quad	0x03ffae89f90000000		# 1.68179
+	.quad	0x03ffb7f76f0000000		# 1.71862
+	.quad	0x03ffc199bd0000000		# 1.75625
+	.quad	0x03ffcb720d0000000		# 1.79471
+	.quad	0x03ffd5818d0000000		# 1.83401
+	.quad	0x03ffdfc9730000000		# 1.87417
+	.quad	0x03ffea4afa0000000		# 1.91521
+	.quad	0x03fff507650000000		# 1.95714
+	.quad 0					# for alignment
+.L__two_to_jby32_trail_table:
+	.quad	0x00000000000000000 # 0
+	.quad	0x03e48ac2ba1d73e2a		# 1.1489e-008
+	.quad	0x03e69f3121ec53172		# 4.83347e-008
+	.quad	0x03df25b50a4ebbf1b		# 2.67125e-010
+	.quad	0x03e68faa2f5b9bef9		# 4.65271e-008
+	.quad	0x03e368b9aa7805b80		# 5.24924e-009
+	.quad	0x03e6ceac470cd83f6		# 5.38622e-008
+	.quad	0x03e547f7b84b09745		# 1.90902e-008
+	.quad	0x03e64636e2a5bd1ab		# 3.79764e-008
+	.quad	0x03e5ceaa72a9c5154		# 2.69307e-008
+	.quad	0x03e682468446b6824		# 4.49684e-008
+	.quad	0x03e18624b40c4dbd0		# 1.41933e-009
+	.quad	0x03e54d8a89c750e5e		# 1.94147e-008
+	.quad	0x03e5a753e077c2a0f		# 2.46409e-008
+	.quad	0x03e6a90a852b19260		# 4.94813e-008
+	.quad	0x03e0d2ac258f87d03		# 8.48872e-010
+	.quad	0x03e59fcef32422cbf		# 2.42032e-008
+	.quad	0x03e61d8bee7ba46e2		# 3.3242e-008
+	.quad	0x03e4f580c36bea881		# 1.45957e-008
+	.quad	0x03e62999c25159f11		# 3.46453e-008
+	.quad	0x03e415506dadd3e2a		# 8.0709e-009
+	.quad	0x03e29b8bc9e8a0388		# 2.99439e-009
+	.quad	0x03e451f8480e3e236		# 9.83622e-009
+	.quad	0x03e41f12ae45a1224		# 8.35492e-009
+	.quad	0x03e62b5a75abd0e6a		# 3.48493e-008
+	.quad	0x03e47daf237553d84		# 1.11085e-008
+	.quad	0x03e6b0aa538444196		# 5.03689e-008
+	.quad	0x03e69df20d22a0798		# 4.81896e-008
+	.quad	0x03e69f7490e4bb40b		# 4.83654e-008
+	.quad	0x03e4bdcdaf5cb4656		# 1.29746e-008
+	.quad	0x03e452486cc2c7b9d		# 9.84533e-009
+	.quad	0x03e66dc8a80ce9f09		# 4.25828e-008
+	.quad 0					# for alignment
+
diff --git a/src/gas/vrdalog.S b/src/gas/vrdalog.S
new file mode 100644
index 0000000..cdbba18
--- /dev/null
+++ b/src/gas/vrdalog.S
@@ -0,0 +1,954 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrdalog.s
+#
+# An array implementation of the log libm function.
+#
+# Prototype:
+#
+#    void vrda_log(int n, double *x, double *y);
+#
+#   Computes the natural log of x.
+#   Returns proper C99 values, but may not raise status flags properly.
+#   Less than 1 ulp of error.  This version can compute logs in 44
+#   cycles with n <= 24
+#
+#
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+# define local variable storage offsets
+.equ	p_x,0			# temporary for error checking operation
+.equ	p_idx,0x010		# index storage
+.equ	p_xexp,0x020		# index storage
+
+.equ	p_x2,0x030		# temporary for error checking operation
+.equ	p_idx2,0x040		# index storage
+.equ	p_xexp2,0x050		# index storage
+
+.equ	save_xa,0x060		#qword
+.equ	save_ya,0x068		#qword
+.equ	save_nv,0x070		#qword
+.equ	p_iter,0x078		# qword	storage for number of loop iterations
+
+.equ	save_rbx,0x080		#qword
+
+
+.equ	p2_temp,0x090		# second temporary for get/put bits operation
+.equ	p2_temp1,0x0b0		# second temporary for exponent multiply
+
+.equ	p_n1,0x0c0		# temporary for near one check
+.equ	p_n12,0x0d0		# temporary for near one check
+
+
+.equ	stack_size,0x0e8
+
+	.weak vrda_log_
+	.set vrda_log_,__vrda_log__
+	.weak vrda_log__
+	.set vrda_log__,__vrda_log__
+
+# parameters are passed in by Linux as:
+# rdi - int n
+# rsi - double *x
+# rdx - double *y
+
+    .text
+    .align 16
+    .p2align 4,,15
+
+#x/* a FORTRAN subroutine implementation of array log
+#**     VRDA_LOG(N,X,Y)
+# C equivalent*/
+#void vrda_log__(int * n, double *x, double *y)
+#{
+#       vrda_log(*n,x,y);
+#}
+.globl __vrda_log__
+    .type   __vrda_log__,@function
+__vrda_log__:
+    mov		(%rdi),%edi
+
+    .align 16
+    .p2align 4,,15
+.globl vrda_log
+    .type   vrda_log,@function
+vrda_log:
+	sub		$stack_size,%rsp
+	mov		%rbx,save_rbx(%rsp)	# save rbx
+
+# save the arguments
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+	mov		%rdx,save_ya(%rsp)	# save y_array pointer
+#ifdef INTEGER64
+        mov             %rdi,%rax
+#else
+        mov             %edi,%eax
+        mov             %rax,%rdi
+#endif
+
+	mov		%rdi,save_nv(%rsp)	# save number of values
+# see if too few values to call the main loop
+	shr		$2,%rax			# get number of iterations
+	jz		.L__vda_cleanup		# jump if only single calls
+# prepare the iteration counts
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	shl		$2,%rax
+	sub		%rax,%rdi		# compute number of extra single calls
+	mov		%rdi,save_nv(%rsp)	# save number of left over values
+
+# In this second version, process the array 2 values at a time.
+
+.L__vda_top:
+# build the input _m128d
+	mov		save_xa(%rsp),%rsi	# get x_array pointer
+	movlpd	(%rsi),%xmm0
+	movhpd	8(%rsi),%xmm0
+	prefetch	64(%rsi)
+	add		$32,%rsi
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+
+                movlpd  -16(%rsi),%xmm7
+                movhpd  -8(%rsi),%xmm7
+
+# compute the logs
+
+##  if NaN or inf
+	movdqa	%xmm0,p_x(%rsp)	# save the input values
+
+#      /* Store the exponent of x in xexp and put
+#         f into the range [0.5,1) */
+
+	pxor	%xmm1,%xmm1
+	movdqa	%xmm0,%xmm3
+	psrlq	$52,%xmm3
+	psubq	.L__mask_1023(%rip),%xmm3
+	packssdw	%xmm1,%xmm3
+	cvtdq2pd	%xmm3,%xmm6			# xexp
+		movdqa	%xmm7,p_x2(%rsp)	# save the input values
+	movdqa	%xmm0,%xmm2
+	subpd	.L__real_one(%rip),%xmm2
+
+	movapd	%xmm6,p_xexp(%rsp)
+	andpd	.L__real_notsign(%rip),%xmm2
+	xor		%rax,%rax
+
+	movdqa	%xmm0,%xmm3
+	pand	.L__real_mant(%rip),%xmm3
+
+	cmppd	$1,.L__real_threshold(%rip),%xmm2
+	movmskpd	%xmm2,%ecx
+	movdqa	%xmm3,%xmm4
+	mov			%ecx,p_n1(%rsp)
+
+#/* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+	psrlq	$45,%xmm3
+	movdqa	%xmm3,%xmm2
+	psrlq	$1,%xmm3
+	paddq	.L__mask_040(%rip),%xmm3
+	pand	.L__mask_001(%rip),%xmm2
+	paddq	%xmm2,%xmm3
+
+	packssdw	%xmm1,%xmm3
+	cvtdq2pd	%xmm3,%xmm1
+		pxor	%xmm7,%xmm7
+		movdqa	p_x2(%rsp),%xmm2
+		movapd	p_x2(%rsp),%xmm5
+		psrlq	$52,%xmm2
+		psubq	.L__mask_1023(%rip),%xmm2
+		packssdw	%xmm7,%xmm2
+		subpd	.L__real_one(%rip),%xmm5
+		andpd	.L__real_notsign(%rip),%xmm5
+		cvtdq2pd	%xmm2,%xmm6			# xexp
+	xor		%rcx,%rcx
+		cmppd	$1,.L__real_threshold(%rip),%xmm5
+	movq	 %xmm3,p_idx(%rsp)
+
+# reduce and get u
+	por		.L__real_half(%rip),%xmm4
+	movdqa	%xmm4,%xmm2
+		movapd	%xmm6,p_xexp2(%rsp)
+
+	# do near one check
+		movmskpd	%xmm5,%edx
+		mov			%edx,p_n12(%rsp)
+
+	mulpd	.L__real_3f80000000000000(%rip),%xmm1				# f1 = index/128
+
+
+	lea		.L__np_ln_lead_table(%rip),%rdx
+	mov		p_idx(%rsp),%eax
+		movdqa	p_x2(%rsp),%xmm6
+
+	movapd	.L__real_half(%rip),%xmm5							# .5
+	subpd	%xmm1,%xmm2											# f2 = f - f1
+		pand	.L__real_mant(%rip),%xmm6
+	mulpd	%xmm2,%xmm5
+	addpd	%xmm5,%xmm1
+
+		movdqa	%xmm6,%xmm8
+		psrlq	$45,%xmm6
+		movdqa	%xmm6,%xmm4
+
+		psrlq	$1,%xmm6
+		paddq	.L__mask_040(%rip),%xmm6
+		pand	.L__mask_001(%rip),%xmm4
+		paddq	%xmm4,%xmm6
+# do error checking here for scheduling.  Saves a bunch of cycles as
+# compared to doing this at the start of the routine.
+##  if NaN or inf
+	movapd	%xmm0,%xmm3
+	andpd	.L__real_inf(%rip),%xmm3
+	cmppd	$0,.L__real_inf(%rip),%xmm3
+	movmskpd	%xmm3,%r8d
+		packssdw	%xmm7,%xmm6
+		por		.L__real_half(%rip),%xmm8
+		movq	 %xmm6,p_idx2(%rsp)
+		cvtdq2pd	%xmm6,%xmm9
+
+	cmppd	$2,.L__real_zero(%rip),%xmm0
+		mulpd	.L__real_3f80000000000000(%rip),%xmm9				# f1 = index/128
+	movmskpd	%xmm0,%r9d
+# delaying this divide helps, but moving the other one does not.
+# it was after the paddq
+	divpd	%xmm1,%xmm2				# u
+
+# compute the index into the log tables
+#
+
+        movlpd   -512(%rdx,%rax,8),%xmm0                # z1
+        mov             p_idx+4(%rsp),%ecx
+        movhpd   -512(%rdx,%rcx,8),%xmm0                # z1
+# solve for ln(1+u)
+	movapd	%xmm2,%xmm1				# u
+	mulpd	%xmm2,%xmm2				# u^2
+	movapd	%xmm2,%xmm5
+	movapd	.L__real_cb3(%rip),%xmm3
+	mulpd	%xmm2,%xmm3				#Cu2
+	mulpd	%xmm1,%xmm5				# u^3
+	addpd	.L__real_cb2(%rip),%xmm3 #B+Cu2
+
+	mulpd	%xmm5,%xmm2				# u^5
+	movapd	.L__real_log2_lead(%rip),%xmm4
+
+	mulpd	.L__real_cb1(%rip),%xmm5 #Au3
+	addpd	%xmm5,%xmm1				# u+Au3
+	mulpd	%xmm3,%xmm2				# u5(B+Cu2)
+
+	movapd	p_xexp(%rsp),%xmm5		# xexp
+	addpd	%xmm2,%xmm1				# poly
+# recombine
+	mulpd	%xmm5,%xmm4				# xexp * log2_lead
+	addpd	%xmm4,%xmm0				#r1
+	lea		.L__np_ln_tail_table(%rip),%rdx
+        movlpd   -512(%rdx,%rax,8),%xmm4                #z2     +=q
+        movhpd   -512(%rdx,%rcx,8),%xmm4                #z2     +=q
+		lea		.L__np_ln_lead_table(%rip),%rdx
+		mov		p_idx2(%rsp),%eax
+		mov		p_idx2+4(%rsp),%ecx
+	addpd	%xmm4,%xmm1
+
+	mulpd	.L__real_log2_tail(%rip),%xmm5
+
+		movapd	.L__real_half(%rip),%xmm4							# .5
+		subpd	%xmm9,%xmm8											# f2 = f - f1
+		mulpd	%xmm8,%xmm4
+		addpd	%xmm4,%xmm9
+
+	addpd	%xmm5,%xmm1				#r2
+		divpd	%xmm9,%xmm8				# u
+		movapd	p_x2(%rsp),%xmm3
+		andpd	.L__real_inf(%rip),%xmm3
+		cmppd	$0,.L__real_inf(%rip),%xmm3
+		movmskpd	%xmm3,%r10d
+		movapd	p_x2(%rsp),%xmm6
+		cmppd	$2,.L__real_zero(%rip),%xmm6
+		movmskpd	%xmm6,%r11d
+
+# check for nans/infs
+	test		$3,%r8d
+	addpd	%xmm1,%xmm0
+	jnz		.L__log_naninf
+.L__vlog1:
+# check for negative numbers or zero
+	test		$3,%r9d
+	jnz		.L__z_or_n
+
+.L__vlog2:
+# store the result _m128d
+	mov		save_ya(%rsp),%rdi	# get y_array pointer
+	movlpd	%xmm0,(%rdi)
+	movhpd	 %xmm0,8(%rdi)
+
+	# It seems like a good idea to try and interleave
+	# even more of the following code sooner into the
+	# program.  But there were conflicts with the table
+	# index registers, making the problem difficult.
+	# After a lot of work in a branch of this file,
+	# I was not able to match the speed of this version.
+	# CodeAnalyst shows that there is lots of unused add
+	# pipe time around the divides, but the processor
+	# doesn't seem to be able to schedule in those slots.
+
+	        movlpd   -512(%rdx,%rax,8),%xmm7                #z2     +=q
+        	movhpd   -512(%rdx,%rcx,8),%xmm7                #z2     +=q
+
+# check for near one
+	mov			p_n1(%rsp),%r9d
+	test			$3,%r9d
+	jnz			.L__near_one1
+.L__vlog2n:
+
+	# solve for ln(1+u)
+		movapd	%xmm8,%xmm9				# u
+		mulpd	%xmm8,%xmm8				# u^2
+		movapd	%xmm8,%xmm5
+		movapd	.L__real_cb3(%rip),%xmm3
+		mulpd	%xmm8,%xmm3				#Cu2
+		mulpd	%xmm9,%xmm5				# u^3
+		addpd	.L__real_cb2(%rip),%xmm3 		#B+Cu2
+
+		mulpd	%xmm5,%xmm8				# u^5
+		movapd	.L__real_log2_lead(%rip),%xmm4
+
+		mulpd	.L__real_cb1(%rip),%xmm5 		#Au3
+		addpd	%xmm5,%xmm9				# u+Au3
+		mulpd	%xmm3,%xmm8				# u5(B+Cu2)
+
+		movapd	p_xexp2(%rsp),%xmm5			# xexp
+		addpd	%xmm8,%xmm9				# poly
+	# recombine
+		mulpd	%xmm5,%xmm4
+		addpd	%xmm4,%xmm7				#r1
+		lea		.L__np_ln_tail_table(%rip),%rdx
+	        movlpd   -512(%rdx,%rax,8),%xmm2                #z2     +=q
+        	movhpd   -512(%rdx,%rcx,8),%xmm2                #z2     +=q
+		addpd	%xmm2,%xmm9
+
+		mulpd	.L__real_log2_tail(%rip),%xmm5
+
+		addpd	%xmm5,%xmm9				#r2
+
+	# check for nans/infs
+		test		$3,%r10d
+		addpd	%xmm9,%xmm7
+		jnz		.L__log_naninf2
+.L__vlog3:
+# check for negative numbers or zero
+		test		$3,%r11d
+		jnz		.L__z_or_n2
+
+.L__vlog4:
+	mov			p_n12(%rsp),%r9d
+	test			$3,%r9d
+	jnz			.L__near_one2
+
+.L__vlog4n:
+
+
+#__vda_bottom2:
+
+	prefetch	64(%rdi)
+	add		$32,%rdi
+	mov		%rdi,save_ya(%rsp)	# save y_array pointer
+
+# store the result _m128d
+		movlpd	%xmm7,-16(%rdi)
+		movhpd	%xmm7,-8(%rdi)
+
+	mov		p_iter(%rsp),%rax	# get number of iterations
+	sub		$1,%rax
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	jnz		.L__vda_top
+
+
+# see if we need to do any extras
+	mov		save_nv(%rsp),%rax	# get number of values
+	test		%rax,%rax
+	jnz		.L__vda_cleanup
+
+
+.L__finish:
+	mov		save_rbx(%rsp),%rbx		# restore rbx
+	add		$stack_size,%rsp
+	ret
+
+	.align	16
+.Lboth_nearone:
+# saves 10 cycles
+#      r = x - 1.0;
+	movapd	.L__real_two(%rip),%xmm2
+	subpd	.L__real_one(%rip),%xmm0	   # r
+#      u          = r / (2.0 + r);
+	addpd	%xmm0,%xmm2
+	movapd	%xmm0,%xmm1
+	divpd	%xmm2,%xmm1		# u
+	movapd	.L__real_ca4(%rip),%xmm4	  #D
+	movapd	.L__real_ca3(%rip),%xmm5	  #C
+#      correction = r * u;
+	movapd	%xmm0,%xmm6
+	mulpd	%xmm1,%xmm6		# correction
+#      u          = u + u;
+	addpd	%xmm1,%xmm1		#u
+	movapd	%xmm1,%xmm2
+	mulpd	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulpd	%xmm1,%xmm5		# Cu
+	movapd	%xmm1,%xmm3
+	mulpd	%xmm2,%xmm3		# u^3
+	mulpd	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulpd	%xmm3,%xmm4		#Du^3
+
+	addpd	.L__real_ca1(%rip),%xmm2	# +A
+	movapd	%xmm3,%xmm1
+	mulpd	%xmm1,%xmm1		# u^6
+	addpd	%xmm4,%xmm5		#Cu+Du3
+
+	mulpd	%xmm3,%xmm2		#u3(A+Bu2)
+	mulpd	%xmm5,%xmm1		#u6(Cu+Du3)
+	addpd	%xmm1,%xmm2
+	subpd	%xmm6,%xmm2		# -correction
+
+#      return r + r2;
+	addpd	%xmm2,%xmm0
+	ret
+
+	.align	16
+.L__near_one1:
+	cmp	$3,%r9d
+	jnz		.L__n1nb1
+
+	movapd	p_x(%rsp),%xmm0
+	call	.Lboth_nearone
+	movlpd	%xmm0,(%rdi)
+	movhpd	%xmm0,8(%rdi)
+	jmp		.L__vlog2n
+
+	.align	16
+.L__n1nb1:
+	test	$1,%r9d
+	jz		.L__lnn12
+
+	movlpd	p_x(%rsp),%xmm0
+	call	.L__ln1
+	movlpd	%xmm0,(%rdi)
+
+.L__lnn12:
+	test	$2,%r9d		# second number?
+	jz		.L__lnn1e
+	movlpd	p_x+8(%rsp),%xmm0
+	call	.L__ln1
+	movlpd	%xmm0,8(%rdi)
+
+.L__lnn1e:
+	jmp		.L__vlog2n
+
+
+	.align	16
+.L__near_one2:
+	cmp	$3,%r9d
+	jnz		.L__n1nb2
+
+	movapd	p_x2(%rsp),%xmm0
+	call	.Lboth_nearone
+	movapd	%xmm0,%xmm7
+	jmp		.L__vlog4n
+
+	.align	16
+.L__n1nb2:
+	test	$1,%r9d
+	jz		.L__lnn22
+
+	movlpd	p_x2(%rsp),%xmm0
+	call	.L__ln1
+	movsd	%xmm0,%xmm7
+
+.L__lnn22:
+	test	$2,%r9d		# second number?
+	jz		.L__lnn2e
+	movlpd	p_x2+8(%rsp),%xmm0
+	call	.L__ln1
+	movlhps	%xmm0,%xmm7
+
+.L__lnn2e:
+	jmp		.L__vlog4n
+
+	.align	16
+
+.L__ln1:
+# saves 10 cycles
+#      r = x - 1.0;
+	movlpd	.L__real_two(%rip),%xmm2
+	subsd	.L__real_one(%rip),%xmm0	   # r
+#      u          = r / (2.0 + r);
+	addsd	%xmm0,%xmm2
+	movsd	%xmm0,%xmm1
+	divsd	%xmm2,%xmm1		# u
+	movlpd	.L__real_ca4(%rip),%xmm4	  #D
+	movlpd	.L__real_ca3(%rip),%xmm5	  #C
+#      correction = r * u;
+	movsd	%xmm0,%xmm6
+	mulsd	%xmm1,%xmm6		# correction
+#      u          = u + u;
+	addsd	%xmm1,%xmm1		#u
+	movsd	%xmm1,%xmm2
+	mulsd	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulsd	%xmm1,%xmm5		# Cu
+	movsd	%xmm1,%xmm3
+	mulsd	%xmm2,%xmm3		# u^3
+	mulsd	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulsd	%xmm3,%xmm4		#Du^3
+
+	addsd	.L__real_ca1(%rip),%xmm2	# +A
+	movsd	%xmm3,%xmm1
+	mulsd	%xmm1,%xmm1		# u^6
+	addsd	%xmm4,%xmm5		#Cu+Du3
+
+	mulsd	%xmm3,%xmm2		#u3(A+Bu2)
+	mulsd	%xmm5,%xmm1		#u6(Cu+Du3)
+	addsd	%xmm1,%xmm2
+	subsd	%xmm6,%xmm2		# -correction
+
+#      return r + r2;
+	addsd	%xmm2,%xmm0
+	ret
+
+	.align	16
+
+# at least one of the numbers was a nan or infinity
+.L__log_naninf:
+	test		$1,%r8d		# first number?
+	jz		.L__lninf2
+
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x(%rsp),%rdx
+	movlpd	p_x(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$2,%xmm1,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__lninf2:
+	test		$2,%r8d		# second number?
+	jz		.L__lninfe
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x+8(%rsp),%rdx
+	movlpd	p_x+8(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$0,%xmm0,%xmm1
+	movapd	%xmm1,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__lninfe:
+	jmp		.L__vlog1		# continue processing if not
+
+# at least one of the numbers was a nan or infinity
+.L__log_naninf2:
+	test		$1,%r10d		# first number?
+	jz		.L__lninf22
+
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm7,%xmm1		# save the inputs
+	mov		p_x2(%rsp),%rdx
+	movlpd	p_x2(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$2,%xmm7,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+	movapd	%xmm0,%xmm7
+
+.L__lninf22:
+	test		$2,%r10d		# second number?
+	jz		.L__lninfe2
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	mov		p_x2+8(%rsp),%rdx
+	movlpd	p_x2+8(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$0,%xmm0,%xmm7
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__lninfe2:
+	jmp		.L__vlog3		# continue processing if not
+
+# a subroutine to treat one number for nan/infinity
+# the number is expected in rdx and returned in the low
+# half of xmm0
+.L__lni:
+	mov		$0x0000FFFFFFFFFFFFF,%rax
+	test	%rax,%rdx
+	jnz		.L__lnan					# jump if mantissa not zero, so it's a NaN
+# inf
+	rcl		$1,%rdx
+	jnc		.L__lne2					# log(+inf) = inf
+# negative x
+	movlpd	.L__real_nan(%rip),%xmm0
+	ret
+
+#NaN
+.L__lnan:
+	mov		$0x00008000000000000,%rax	# convert to quiet
+	or		%rax,%rdx
+.L__lne:
+	movd	%rdx,%xmm0
+.L__lne2:
+	ret
+
+	.align	16
+
+# at least one of the numbers was a zero, a negative number, or both.
+.L__z_or_n:
+	test		$1,%r9d		# first number?
+	jz		.L__zn2
+
+	mov		%rax,p2_temp(%rsp)
+ 	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x(%rsp),%rax
+	call	.L__zni
+	shufpd	$2,%xmm1,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__zn2:
+	test		$2,%r9d		# second number?
+	jz		.L__zne
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x+8(%rsp),%rax
+	call	.L__zni
+	shufpd	$0,%xmm0,%xmm1
+	movapd	%xmm1,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__zne:
+	jmp		.L__vlog2
+
+.L__z_or_n2:
+	test		$1,%r11d		# first number?
+	jz		.L__zn22
+
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	mov		p_x2(%rsp),%rax
+	call	.L__zni
+	shufpd	$2,%xmm7,%xmm0
+	movapd	%xmm0,%xmm7
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__zn22:
+	test		$2,%r11d		# second number?
+	jz		.L__zne2
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	mov		p_x2+8(%rsp),%rax
+	call	.L__zni
+	shufpd	$0,%xmm0,%xmm7
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__zne2:
+	jmp		.L__vlog4
+# a subroutine to treat one number for zero or negative values
+# the number is expected in rax and returned in the low
+# half of xmm0
+.L__zni:
+	shl		$1,%rax
+	jnz		.L__zn_x		 # if just a carry, then must be negative
+	movlpd	.L__real_ninf(%rip),%xmm0  # C99 specs -inf for +-0
+	ret
+.L__zn_x:
+	movlpd	.L__real_nan(%rip),%xmm0
+	ret
+
+
+# we jump here when we have an odd number of log calls to make at the
+# end
+#  we assume that rdx is pointing at the next x array element,
+#  r8 at the next y array element.  The number of values left is in
+#  save_nv
+.L__vda_cleanup:
+        mov             save_nv(%rsp),%rax      # get number of values
+        test            %rax,%rax               # are there any values
+        jz              .L__finish         # exit if not
+
+	mov		save_xa(%rsp),%rsi
+	mov		save_ya(%rsp),%rdi
+
+# fill in a m128d with zeroes and the extra values and then make a recursive call.
+	xorpd		%xmm0,%xmm0
+	movlpd	%xmm0,p_x+8(%rsp)
+	movapd	%xmm0,p_x+16(%rsp)
+
+	mov		(%rsi),%rcx			# we know there's at least one
+	mov	 	%rcx,p_x(%rsp)
+	cmp		$2,%rax
+	jl		.L__vdacg
+
+	mov		8(%rsi),%rcx			# do the second value
+	mov	 	%rcx,p_x+8(%rsp)
+	cmp		$3,%rax
+	jl		.L__vdacg
+
+	mov		16(%rsi),%rcx			# do the third value
+	mov	 	%rcx,p_x+16(%rsp)
+
+.L__vdacg:
+	mov		$4,%rdi				# parameter for N
+	lea		p_x(%rsp),%rsi		# &x parameter
+	lea		p2_temp(%rsp),%rdx	# &y parameter
+	call		vrda_log@PLT		# call recursively to compute four values
+
+# now copy the results to the destination array
+	mov		save_ya(%rsp),%rdi
+	mov		save_nv(%rsp),%rax	# get number of values
+	mov	 	p2_temp(%rsp),%rcx
+	mov		%rcx,(%rdi)			# we know there's at least one
+	cmp		$2,%rax
+	jl		.L__vdacgf
+
+	mov	 	p2_temp+8(%rsp),%rcx
+	mov		%rcx,8(%rdi)			# do the second value
+	cmp		$3,%rax
+	jl		.L__vdacgf
+
+	mov	 	p2_temp+16(%rsp),%rcx
+	mov		%rcx,16(%rdi)			# do the third value
+
+.L__vdacgf:
+	jmp		.L__finish
+
+	.data
+	.align	64
+
+.L__real_one:			.quad 0x03ff0000000000000	# 1.0
+				.quad 0x03ff0000000000000
+.L__real_two:			.quad 0x04000000000000000	# 2.0
+				.quad 0x04000000000000000
+.L__real_ninf:			.quad 0x0fff0000000000000	# -inf
+				.quad 0x0fff0000000000000
+.L__real_inf:			.quad 0x07ff0000000000000	# +inf
+				.quad 0x07ff0000000000000
+.L__real_nan:			.quad 0x07ff8000000000000	# NaN
+				.quad 0x07ff8000000000000
+
+.L__real_zero:			.quad 0x00000000000000000	# 0.0
+				.quad 0x00000000000000000
+
+.L__real_sign:			.quad 0x08000000000000000	# sign bit
+				.quad 0x08000000000000000
+.L__real_notsign:		.quad 0x07ffFFFFFFFFFFFFF	# ^sign bit
+				.quad 0x07ffFFFFFFFFFFFFF
+.L__real_threshold:		.quad 0x03F9EB85000000000	# .03
+				.quad 0x03F9EB85000000000
+.L__real_qnanbit:		.quad 0x00008000000000000	# quiet nan bit
+				.quad 0x00008000000000000
+.L__real_mant:			.quad 0x0000FFFFFFFFFFFFF	# mantissa bits
+				.quad 0x0000FFFFFFFFFFFFF
+.L__real_3f80000000000000:	.quad 0x03f80000000000000	# /* 0.0078125 = 1/128 */
+				.quad 0x03f80000000000000
+.L__mask_1023:			.quad 0x000000000000003ff	#
+				.quad 0x000000000000003ff
+.L__mask_040:			.quad 0x00000000000000040	#
+				.quad 0x00000000000000040
+.L__mask_001:			.quad 0x00000000000000001	#
+				.quad 0x00000000000000001
+
+.L__real_ca1:			.quad 0x03fb55555555554e6	# 8.33333333333317923934e-02
+				.quad 0x03fb55555555554e6
+.L__real_ca2:			.quad 0x03f89999999bac6d4	# 1.25000000037717509602e-02
+				.quad 0x03f89999999bac6d4
+.L__real_ca3:			.quad 0x03f62492307f1519f	# 2.23213998791944806202e-03
+				.quad 0x03f62492307f1519f
+.L__real_ca4:			.quad 0x03f3c8034c85dfff0	# 4.34887777707614552256e-04
+				.quad 0x03f3c8034c85dfff0
+
+.L__real_cb1:			.quad 0x03fb5555555555557	# 8.33333333333333593622e-02
+				.quad 0x03fb5555555555557
+.L__real_cb2:			.quad 0x03f89999999865ede	# 1.24999999978138668903e-02
+				.quad 0x03f89999999865ede
+.L__real_cb3:			.quad 0x03f6249423bd94741	# 2.23219810758559851206e-03
+				.quad 0x03f6249423bd94741
+.L__real_log2_lead:  		.quad 0x03fe62e42e0000000	# log2_lead	  6.93147122859954833984e-01
+				.quad 0x03fe62e42e0000000
+.L__real_log2_tail: 		.quad 0x03e6efa39ef35793c	# log2_tail	  5.76999904754328540596e-08
+				.quad 0x03e6efa39ef35793c
+
+.L__real_half:			.quad 0x03fe0000000000000	# 1/2
+				.quad 0x03fe0000000000000
+
+
+.L__np_ln_lead_table:
+	.quad	0x0000000000000000 		# 0.00000000000000000000e+00
+	.quad	0x3f8fc0a800000000		# 1.55041813850402832031e-02
+	.quad	0x3f9f829800000000		# 3.07716131210327148438e-02
+	.quad	0x3fa7745800000000		# 4.58095073699951171875e-02
+	.quad	0x3faf0a3000000000		# 6.06245994567871093750e-02
+	.quad	0x3fb341d700000000		# 7.52233862876892089844e-02
+	.quad	0x3fb6f0d200000000		# 8.96121263504028320312e-02
+	.quad	0x3fba926d00000000		# 1.03796780109405517578e-01
+	.quad	0x3fbe270700000000		# 1.17783010005950927734e-01
+	.quad	0x3fc0d77e00000000		# 1.31576299667358398438e-01
+	.quad	0x3fc2955280000000		# 1.45181953907012939453e-01
+	.quad	0x3fc44d2b00000000		# 1.58604979515075683594e-01
+	.quad	0x3fc5ff3000000000		# 1.71850204467773437500e-01
+	.quad	0x3fc7ab8900000000		# 1.84922337532043457031e-01
+	.quad	0x3fc9525a80000000		# 1.97825729846954345703e-01
+	.quad	0x3fcaf3c900000000		# 2.10564732551574707031e-01
+	.quad	0x3fcc8ff780000000		# 2.23143517971038818359e-01
+	.quad	0x3fce270700000000		# 2.35566020011901855469e-01
+	.quad	0x3fcfb91800000000		# 2.47836112976074218750e-01
+	.quad	0x3fd0a324c0000000		# 2.59957492351531982422e-01
+	.quad	0x3fd1675c80000000		# 2.71933674812316894531e-01
+	.quad	0x3fd22941c0000000		# 2.83768117427825927734e-01
+	.quad	0x3fd2e8e280000000		# 2.95464158058166503906e-01
+	.quad	0x3fd3a64c40000000		# 3.07025015354156494141e-01
+	.quad	0x3fd4618bc0000000		# 3.18453729152679443359e-01
+	.quad	0x3fd51aad80000000		# 3.29753279685974121094e-01
+	.quad	0x3fd5d1bd80000000		# 3.40926527976989746094e-01
+	.quad	0x3fd686c800000000		# 3.51976394653320312500e-01
+	.quad	0x3fd739d7c0000000		# 3.62905442714691162109e-01
+	.quad	0x3fd7eaf800000000		# 3.73716354370117187500e-01
+	.quad	0x3fd89a3380000000		# 3.84411692619323730469e-01
+	.quad	0x3fd9479400000000		# 3.94993782043457031250e-01
+	.quad	0x3fd9f323c0000000		# 4.05465066432952880859e-01
+	.quad	0x3fda9cec80000000		# 4.15827870368957519531e-01
+	.quad	0x3fdb44f740000000		# 4.26084339618682861328e-01
+	.quad	0x3fdbeb4d80000000		# 4.36236739158630371094e-01
+	.quad	0x3fdc8ff7c0000000		# 4.46287095546722412109e-01
+	.quad	0x3fdd32fe40000000		# 4.56237375736236572266e-01
+	.quad	0x3fddd46a00000000		# 4.66089725494384765625e-01
+	.quad	0x3fde744240000000		# 4.75845873355865478516e-01
+	.quad	0x3fdf128f40000000		# 4.85507786273956298828e-01
+	.quad	0x3fdfaf5880000000		# 4.95077252388000488281e-01
+	.quad	0x3fe02552a0000000		# 5.04556000232696533203e-01
+	.quad	0x3fe0723e40000000		# 5.13945698738098144531e-01
+	.quad	0x3fe0be72e0000000		# 5.23248136043548583984e-01
+	.quad	0x3fe109f380000000		# 5.32464742660522460938e-01
+	.quad	0x3fe154c3c0000000		# 5.41597247123718261719e-01
+	.quad	0x3fe19ee6a0000000		# 5.50647079944610595703e-01
+	.quad	0x3fe1e85f40000000		# 5.59615731239318847656e-01
+	.quad	0x3fe23130c0000000		# 5.68504691123962402344e-01
+	.quad	0x3fe2795e00000000		# 5.77315330505371093750e-01
+	.quad	0x3fe2c0e9e0000000		# 5.86049020290374755859e-01
+	.quad	0x3fe307d720000000		# 5.94707071781158447266e-01
+	.quad	0x3fe34e2880000000		# 6.03290796279907226562e-01
+	.quad	0x3fe393e0c0000000		# 6.11801505088806152344e-01
+	.quad	0x3fe3d90260000000		# 6.20240390300750732422e-01
+	.quad	0x3fe41d8fe0000000		# 6.28608644008636474609e-01
+	.quad	0x3fe4618bc0000000		# 6.36907458305358886719e-01
+	.quad	0x3fe4a4f840000000		# 6.45137906074523925781e-01
+	.quad	0x3fe4e7d800000000		# 6.53301239013671875000e-01
+	.quad	0x3fe52a2d20000000		# 6.61398470401763916016e-01
+	.quad	0x3fe56bf9c0000000		# 6.69430613517761230469e-01
+	.quad	0x3fe5ad4040000000		# 6.77398800849914550781e-01
+	.quad	0x3fe5ee02a0000000		# 6.85303986072540283203e-01
+	.quad	0x3fe62e42e0000000		# 6.93147122859954833984e-01
+	.quad 0					# for alignment
+
+.L__np_ln_tail_table:
+	.quad	0x00000000000000000 # 0	; 0.00000000000000000000e+00
+	.quad	0x03e361f807c79f3db		# 5.15092497094772879206e-09
+	.quad	0x03e6873c1980267c8		# 4.55457209735272790188e-08
+	.quad	0x03e5ec65b9f88c69e		# 2.86612990859791781788e-08
+	.quad	0x03e58022c54cc2f99		# 2.23596477332056055352e-08
+	.quad	0x03e62c37a3a125330		# 3.49498983167142274770e-08
+	.quad	0x03e615cad69737c93		# 3.23392843005887000414e-08
+	.quad	0x03e4d256ab1b285e9		# 1.35722380472479366661e-08
+	.quad	0x03e5b8abcb97a7aa2		# 2.56504325268044191098e-08
+	.quad	0x03e6f34239659a5dc		# 5.81213608741512136843e-08
+	.quad	0x03e6e07fd48d30177		# 5.59374849578288093334e-08
+	.quad	0x03e6b32df4799f4f6		# 5.06615629004996189970e-08
+	.quad	0x03e6c29e4f4f21cf8		# 5.24588857848400955725e-08
+	.quad	0x03e1086c848df1b59		# 9.61968535632653505972e-10
+	.quad	0x03e4cf456b4764130		# 1.34829655346594463137e-08
+	.quad	0x03e63a02ffcb63398		# 3.65557749306383026498e-08
+	.quad	0x03e61e6a6886b0976		# 3.33431709374069198903e-08
+	.quad	0x03e6b8abcb97a7aa2		# 5.13008650536088382197e-08
+	.quad	0x03e6b578f8aa35552		# 5.09285070380306053751e-08
+	.quad	0x03e6139c871afb9fc		# 3.20853940845502057341e-08
+	.quad	0x03e65d5d30701ce64		# 4.06713248643004200446e-08
+	.quad	0x03e6de7bcb2d12142		# 5.57028186706125221168e-08
+	.quad	0x03e6d708e984e1664		# 5.48356693724804282546e-08
+	.quad	0x03e556945e9c72f36		# 1.99407553679345001938e-08
+	.quad	0x03e20e2f613e85bda		# 1.96585517245087232086e-09
+	.quad	0x03e3cb7e0b42724f6		# 6.68649386072067321503e-09
+	.quad	0x03e6fac04e52846c7		# 5.89936034642113390002e-08
+	.quad	0x03e5e9b14aec442be		# 2.85038578721554472484e-08
+	.quad	0x03e6b5de8034e7126		# 5.09746772910284482606e-08
+	.quad	0x03e6dc157e1b259d3		# 5.54234668933210171467e-08
+	.quad	0x03e3b05096ad69c62		# 6.29100830926604004874e-09
+	.quad	0x03e5c2116faba4cdd		# 2.61974119468563937716e-08
+	.quad	0x03e665fcc25f95b47		# 4.16752115011186398935e-08
+	.quad	0x03e5a9a08498d4850		# 2.47747534460820790327e-08
+	.quad	0x03e6de647b1465f77		# 5.56922172017964209793e-08
+	.quad	0x03e5da71b7bf7861d		# 2.76162876992552906035e-08
+	.quad	0x03e3e6a6886b09760		# 7.08169709942321478061e-09
+	.quad	0x03e6f0075eab0ef64		# 5.77453510221151779025e-08
+	.quad	0x03e33071282fb989b		# 4.43021445893361960146e-09
+	.quad	0x03e60eb43c3f1bed2		# 3.15140984357495864573e-08
+	.quad	0x03e5faf06ecb35c84		# 2.95077445089736670973e-08
+	.quad	0x03e4ef1e63db35f68		# 1.44098510263167149349e-08
+	.quad	0x03e469743fb1a71a5		# 1.05196987538551827693e-08
+	.quad	0x03e6c1cdf404e5796		# 5.23641361722697546261e-08
+	.quad	0x03e4094aa0ada625e		# 7.72099925253243069458e-09
+	.quad	0x03e6e2d4c96fde3ec		# 5.62089493829364197156e-08
+	.quad	0x03e62f4d5e9a98f34		# 3.53090261098577946927e-08
+	.quad	0x03e6467c96ecc5cbe		# 3.80080516835568242269e-08
+	.quad	0x03e6e7040d03dec5a		# 5.66961038386146408282e-08
+	.quad	0x03e67bebf4282de36		# 4.42287063097349852717e-08
+	.quad	0x03e6289b11aeb783f		# 3.45294525105681104660e-08
+	.quad	0x03e5a891d1772f538		# 2.47132034530447431509e-08
+	.quad	0x03e634f10be1fb591		# 3.59655343422487209774e-08
+	.quad	0x03e6d9ce1d316eb93		# 5.51581770357780862071e-08
+	.quad	0x03e63562a19a9c442		# 3.60171867511861372793e-08
+	.quad	0x03e54e2adf548084c		# 1.94511067964296180547e-08
+	.quad	0x03e508ce55cc8c97a		# 1.54137376631349347838e-08
+	.quad	0x03e30e2f613e85bda		# 3.93171034490174464173e-09
+	.quad	0x03e6db03ebb0227bf		# 5.52990607758839766440e-08
+	.quad	0x03e61b75bb09cb098		# 3.29990737637586136511e-08
+	.quad	0x03e496f16abb9df22		# 1.18436010922446096216e-08
+	.quad	0x03e65b3f399411c62		# 4.04248680368301346709e-08
+	.quad	0x03e586b3e59f65355		# 2.27418915900284316293e-08
+	.quad	0x03e52482ceae1ac12		# 1.70263791333409206020e-08
+	.quad	0x03e6efa39ef35793c		# 5.76999904754328540596e-08
+	.quad 0					# for alignment
+
diff --git a/src/gas/vrdalog10.S b/src/gas/vrdalog10.S
new file mode 100644
index 0000000..f766b62
--- /dev/null
+++ b/src/gas/vrdalog10.S
@@ -0,0 +1,1021 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrdalog10.s
+#
+# An array implementation of the log10 libm function.
+#
+# Prototype:
+#
+#    void vrda_log10(int n, double *x, double *y);
+#
+#   Computes the natural log10 of x.
+#   Returns proper C99 values, but may not raise status flags properly.
+#   Less than 1 ulp of error.  This version can compute log10s in 50-55
+#   cycles with n <= 24
+#
+#
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+        .weak vrda_log10_
+        .set vrda_log10_,__vrda_log10__
+        .weak vrda_log10__
+        .set vrda_log10__,__vrda_log10__
+
+# parameters are passed in by Linux as:
+# rdi - int n
+# rsi - double *x
+# rdx - double *y
+
+    .text
+    .align 16
+    .p2align 4,,15
+
+#x/* a FORTRAN subroutine implementation of array log10
+#**     VRDA_LOG(N,X,Y)
+# C equivalent*/
+#void vrda_log10__(int * n, double *x, double *y)
+#{
+#       vrda_log10(*n,x,y);
+#}
+.globl __vrda_log10__
+    .type   __vrda_log10__,@function
+__vrda_log10__:
+    mov         (%rdi),%edi
+
+# define local variable storage offsets
+.equ	p_x,0			# temporary for error checking operation
+.equ	p_idx,0x010		# index storage
+.equ	p_xexp,0x020		# index storage
+
+.equ	p_x2,0x030		# temporary for error checking operation
+.equ	p_idx2,0x040		# index storage
+.equ	p_xexp2,0x050		# index storage
+
+.equ	save_xa,0x060		#qword
+.equ	save_ya,0x068		#qword
+.equ	save_nv,0x070		#qword
+.equ	p_iter,0x078		# qword	storage for number of loop iterations
+
+.equ	save_rbx,0x080		#qword
+
+
+.equ	p2_temp,0x090		# second temporary for get/put bits operation
+.equ	p2_temp1,0x0b0		# second temporary for exponent multiply
+
+.equ	p_n1,0x0c0		# temporary for near one check
+.equ	p_n12,0x0d0		# temporary for near one check
+
+
+.equ	stack_size,0x0e8
+
+
+# parameters are passed in by Microsoft C as:
+# rdi - int n
+# rsi - double *x
+# rdx - double *y
+
+    .text
+    .align 16
+    .p2align 4,,15
+.globl vrda_log10
+    .type   vrda_log10,@function
+vrda_log10:
+	sub		$stack_size,%rsp
+	mov		%rbx,save_rbx(%rsp)	# save rbx
+
+# save the arguments
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+	mov		%rdx,save_ya(%rsp)	# save y_array pointer
+#ifdef INTEGER64
+        mov             %rdi,%rax
+#else
+        mov             %edi,%eax
+        mov             %rax,%rdi
+#endif
+
+	mov		%rdi,save_nv(%rsp)	# save number of values
+# see if too few values to call the main loop
+	shr		$2,%rax			# get number of iterations
+	jz		.L__vda_cleanup		# jump if only single calls
+# prepare the iteration counts
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	shl		$2,%rax
+	sub		%rax,%rdi		# compute number of extra single calls
+	mov		%rdi,save_nv(%rsp)	# save number of left over values
+
+# In this second version, process the array 2 values at a time.
+
+.L__vda_top:
+# build the input _m128d
+	mov		save_xa(%rsp),%rsi	# get x_array pointer
+	movlpd	(%rsi),%xmm0
+	movhpd	8(%rsi),%xmm0
+	prefetch	64(%rsi)
+	add		$32,%rsi
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+
+                movlpd  -16(%rsi),%xmm7
+                movhpd  -8(%rsi),%xmm7
+
+# compute the log10s
+
+##  if NaN or inf
+	movdqa	%xmm0,p_x(%rsp)	# save the input values
+
+#      /* Store the exponent of x in xexp and put
+#         f into the range [0.5,1) */
+
+	pxor	%xmm1,%xmm1
+	movdqa	%xmm0,%xmm3
+	psrlq	$52,%xmm3
+	psubq	.L__mask_1023(%rip),%xmm3
+	packssdw	%xmm1,%xmm3
+	cvtdq2pd	%xmm3,%xmm6			# xexp
+		movdqa	%xmm7,p_x2(%rsp)	# save the input values
+	movdqa	%xmm0,%xmm2
+	subpd	.L__real_one(%rip),%xmm2
+
+	movapd	%xmm6,p_xexp(%rsp)
+	andpd	.L__real_notsign(%rip),%xmm2
+	xor		%rax,%rax
+
+	movdqa	%xmm0,%xmm3
+	pand	.L__real_mant(%rip),%xmm3
+
+	cmppd	$1,.L__real_threshold(%rip),%xmm2
+	movmskpd	%xmm2,%ecx
+	movdqa	%xmm3,%xmm4
+	mov			%ecx,p_n1(%rsp)
+
+#/* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+	psrlq	$45,%xmm3
+	movdqa	%xmm3,%xmm2
+	psrlq	$1,%xmm3
+	paddq	.L__mask_040(%rip),%xmm3
+	pand	.L__mask_001(%rip),%xmm2
+	paddq	%xmm2,%xmm3
+
+	packssdw	%xmm1,%xmm3
+	cvtdq2pd	%xmm3,%xmm1
+		pxor	%xmm7,%xmm7
+		movdqa	p_x2(%rsp),%xmm2
+		movapd	p_x2(%rsp),%xmm5
+		psrlq	$52,%xmm2
+		psubq	.L__mask_1023(%rip),%xmm2
+		packssdw	%xmm7,%xmm2
+		subpd	.L__real_one(%rip),%xmm5
+		andpd	.L__real_notsign(%rip),%xmm5
+		cvtdq2pd	%xmm2,%xmm6			# xexp
+	xor		%rcx,%rcx
+		cmppd	$1,.L__real_threshold(%rip),%xmm5
+	movq	 %xmm3,p_idx(%rsp)
+
+# reduce and get u
+	por		.L__real_half(%rip),%xmm4
+	movdqa	%xmm4,%xmm2
+		movapd	%xmm6,p_xexp2(%rsp)
+
+	# do near one check
+		movmskpd	%xmm5,%edx
+		mov			%edx,p_n12(%rsp)
+
+	mulpd	.L__real_3f80000000000000(%rip),%xmm1				# f1 = index/128
+
+
+	lea		.L__np_ln_lead_table(%rip),%rdx
+	mov		p_idx(%rsp),%eax
+		movdqa	p_x2(%rsp),%xmm6
+
+	movapd	.L__real_half(%rip),%xmm5							# .5
+	subpd	%xmm1,%xmm2											# f2 = f - f1
+		pand	.L__real_mant(%rip),%xmm6
+	mulpd	%xmm2,%xmm5
+	addpd	%xmm5,%xmm1
+
+		movdqa	%xmm6,%xmm8
+		psrlq	$45,%xmm6
+		movdqa	%xmm6,%xmm4
+
+		psrlq	$1,%xmm6
+		paddq	.L__mask_040(%rip),%xmm6
+		pand	.L__mask_001(%rip),%xmm4
+		paddq	%xmm4,%xmm6
+# do error checking here for scheduling.  Saves a bunch of cycles as
+# compared to doing this at the start of the routine.
+##  if NaN or inf
+	movapd	%xmm0,%xmm3
+	andpd	.L__real_inf(%rip),%xmm3
+	cmppd	$0,.L__real_inf(%rip),%xmm3
+	movmskpd	%xmm3,%r8d
+		packssdw	%xmm7,%xmm6
+		por		.L__real_half(%rip),%xmm8
+		movq	 %xmm6,p_idx2(%rsp)
+		cvtdq2pd	%xmm6,%xmm9
+
+	cmppd	$2,.L__real_zero(%rip),%xmm0
+		mulpd	.L__real_3f80000000000000(%rip),%xmm9				# f1 = index/128
+	movmskpd	%xmm0,%r9d
+# delaying this divide helps, but moving the other one does not.
+# it was after the paddq
+	divpd	%xmm1,%xmm2				# u
+
+# compute the index into the log10 tables
+#
+
+        movlpd   -512(%rdx,%rax,8),%xmm0                # z1
+        mov             p_idx+4(%rsp),%ecx
+        movhpd   -512(%rdx,%rcx,8),%xmm0                # z1
+# solve for ln(1+u)
+	movapd	%xmm2,%xmm1				# u
+	mulpd	%xmm2,%xmm2				# u^2
+	movapd	%xmm2,%xmm5
+	movapd	.L__real_cb3(%rip),%xmm3
+	mulpd	%xmm2,%xmm3				#Cu2
+	mulpd	%xmm1,%xmm5				# u^3
+	addpd	.L__real_cb2(%rip),%xmm3 #B+Cu2
+
+	mulpd	%xmm5,%xmm2				# u^5
+	movapd	.L__real_log2_lead(%rip),%xmm4
+
+	mulpd	.L__real_cb1(%rip),%xmm5 #Au3
+	addpd	%xmm5,%xmm1				# u+Au3
+	mulpd	%xmm3,%xmm2				# u5(B+Cu2)
+
+	movapd	p_xexp(%rsp),%xmm5		# xexp
+	addpd	%xmm2,%xmm1				# poly
+# recombine
+	mulpd	%xmm5,%xmm4				# xexp * log2_lead
+	addpd	%xmm4,%xmm0				#r1
+	movapd  %xmm0,%xmm2				#for log10
+	lea		.L__np_ln_tail_table(%rip),%rdx
+        movlpd   -512(%rdx,%rax,8),%xmm4                #z2     +=q
+        movhpd   -512(%rdx,%rcx,8),%xmm4                #z2     +=q
+        mulpd 	.L__real_log10e_tail(%rip),%xmm0	#for log10
+	    mulpd 	.L__real_log10e_lead(%rip),%xmm2  #for log10
+		lea		.L__np_ln_lead_table(%rip),%rdx
+		mov		p_idx2(%rsp),%eax
+		mov		p_idx2+4(%rsp),%ecx
+	addpd	%xmm4,%xmm1
+
+	mulpd	.L__real_log2_tail(%rip),%xmm5
+
+		movapd	.L__real_half(%rip),%xmm4							# .5
+		subpd	%xmm9,%xmm8											# f2 = f - f1
+		mulpd	%xmm8,%xmm4
+		addpd	%xmm4,%xmm9
+
+	addpd	%xmm5,%xmm1				#r2
+		movapd  %xmm1,%xmm7				#for log10
+		mulpd 	.L__real_log10e_tail(%rip),%xmm1 #for log10
+		addpd   %xmm1,%xmm0		#for log10
+
+		divpd	%xmm9,%xmm8				# u
+		movapd	p_x2(%rsp),%xmm3
+		mulpd   .L__real_log10e_lead(%rip),%xmm7 #log10
+		andpd	.L__real_inf(%rip),%xmm3
+		cmppd	$0,.L__real_inf(%rip),%xmm3
+		movmskpd	%xmm3,%r10d
+		addpd   %xmm7,%xmm0		#for log10
+		movapd	p_x2(%rsp),%xmm6
+		cmppd	$2,.L__real_zero(%rip),%xmm6
+		movmskpd	%xmm6,%r11d
+
+# check for nans/infs
+	test		$3,%r8d
+	addpd  %xmm2,%xmm0	#for log10
+#	addpd	%xmm1,%xmm0
+	jnz		.L__log_naninf
+.L__vlog1:
+# check for negative numbers or zero
+	test		$3,%r9d
+	jnz		.L__z_or_n
+
+.L__vlog2:
+# store the result _m128d
+	mov		save_ya(%rsp),%rdi	# get y_array pointer
+	movlpd	%xmm0,(%rdi)
+	movhpd	 %xmm0,8(%rdi)
+
+	# It seems like a good idea to try and interleave
+	# even more of the following code sooner into the
+	# program.  But there were conflicts with the table
+	# index registers, making the problem difficult.
+	# After a lot of work in a branch of this file,
+	# I was not able to match the speed of this version.
+	# CodeAnalyst shows that there is lots of unused add
+	# pipe time around the divides, but the processor
+	# doesn't seem to be able to schedule in those slots.
+
+	        movlpd   -512(%rdx,%rax,8),%xmm7                #z2     +=q
+        	movhpd   -512(%rdx,%rcx,8),%xmm7                #z2     +=q
+
+# check for near one
+	mov			p_n1(%rsp),%r9d
+	test			$3,%r9d
+	jnz			.L__near_one1
+.L__vlog2n:
+
+	# solve for ln(1+u)
+		movapd	%xmm8,%xmm9				# u
+		mulpd	%xmm8,%xmm8				# u^2
+		movapd	%xmm8,%xmm5
+		movapd	.L__real_cb3(%rip),%xmm3
+		mulpd	%xmm8,%xmm3				#Cu2
+		mulpd	%xmm9,%xmm5				# u^3
+		addpd	.L__real_cb2(%rip),%xmm3 		#B+Cu2
+
+		mulpd	%xmm5,%xmm8				# u^5
+		movapd	.L__real_log2_lead(%rip),%xmm4
+
+		mulpd	.L__real_cb1(%rip),%xmm5 		#Au3
+		addpd	%xmm5,%xmm9				# u+Au3
+		mulpd	%xmm3,%xmm8				# u5(B+Cu2)
+
+		movapd	p_xexp2(%rsp),%xmm5			# xexp
+		addpd	%xmm8,%xmm9				# poly
+	# recombine
+		mulpd	%xmm5,%xmm4
+		addpd	%xmm4,%xmm7				#r1
+		movapd 	%xmm7,%xmm6			#for log10
+
+		lea		.L__np_ln_tail_table(%rip),%rdx
+		mulpd 	.L__real_log10e_tail(%rip),%xmm7 #for log10
+	        movlpd   -512(%rdx,%rax,8),%xmm2                #z2     +=q
+	    mulpd 	.L__real_log10e_lead(%rip),%xmm6 #for log10
+        	movhpd   -512(%rdx,%rcx,8),%xmm2                #z2     +=q
+		addpd	%xmm2,%xmm9
+
+		mulpd	.L__real_log2_tail(%rip),%xmm5
+
+		addpd	%xmm5,%xmm9				#r2
+		movapd  %xmm9,%xmm8				#for log10
+		mulpd 	.L__real_log10e_tail(%rip),%xmm9 #for log 10
+		addpd   %xmm9,%xmm7 	#for log10
+		mulpd 	.L__real_log10e_lead(%rip),%xmm8 #for log10
+		addpd	%xmm8,%xmm7 	#for log10
+
+	# check for nans/infs
+		test		$3,%r10d
+		addpd   %xmm6,%xmm7	#for log10
+#		addpd	%xmm9,%xmm7
+		jnz		.L__log_naninf2
+.L__vlog3:
+# check for negative numbers or zero
+		test		$3,%r11d
+		jnz		.L__z_or_n2
+
+.L__vlog4:
+	mov			p_n12(%rsp),%r9d
+	test			$3,%r9d
+	jnz			.L__near_one2
+
+.L__vlog4n:
+
+
+#__vda_bottom2:
+
+	prefetch	64(%rdi)
+	add		$32,%rdi
+	mov		%rdi,save_ya(%rsp)	# save y_array pointer
+
+# store the result _m128d
+		movlpd	%xmm7,-16(%rdi)
+		movhpd	%xmm7,-8(%rdi)
+
+	mov		p_iter(%rsp),%rax	# get number of iterations
+	sub		$1,%rax
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	jnz		.L__vda_top
+
+
+# see if we need to do any extras
+	mov		save_nv(%rsp),%rax	# get number of values
+	test		%rax,%rax
+	jnz		.L__vda_cleanup
+
+
+.L__finish:
+	mov		save_rbx(%rsp),%rbx		# restore rbx
+	add		$stack_size,%rsp
+	ret
+
+	.align	16
+.Lboth_nearone:
+# saves 10 cycles
+#      r = x - 1.0;
+	movapd	.L__real_two(%rip),%xmm2
+	subpd	.L__real_one(%rip),%xmm0	   # r
+#      u          = r / (2.0 + r);
+	addpd	%xmm0,%xmm2
+	movapd	%xmm0,%xmm1
+	divpd	%xmm2,%xmm1		# u
+	movapd	.L__real_ca4(%rip),%xmm4	  #D
+	movapd	.L__real_ca3(%rip),%xmm5	  #C
+#      correction = r * u;
+	movapd	%xmm0,%xmm6
+	mulpd	%xmm1,%xmm6		# correction
+#      u          = u + u;
+	addpd	%xmm1,%xmm1		#u
+	movapd	%xmm1,%xmm2
+	mulpd	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulpd	%xmm1,%xmm5		# Cu
+	movapd	%xmm1,%xmm3
+	mulpd	%xmm2,%xmm3		# u^3
+	mulpd	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulpd	%xmm3,%xmm4		#Du^3
+
+	addpd	.L__real_ca1(%rip),%xmm2	# +A
+	movapd	%xmm3,%xmm1
+	mulpd	%xmm1,%xmm1		# u^6
+	addpd	%xmm4,%xmm5		#Cu+Du3
+
+	mulpd	%xmm3,%xmm2		#u3(A+Bu2)
+	mulpd	%xmm5,%xmm1		#u6(Cu+Du3)
+	addpd	%xmm1,%xmm2
+	subpd	%xmm6,%xmm2		# -correction
+
+#	loge to log10
+	movapd 	%xmm0,%xmm3		#r1 = r
+	pand	.L__mask_lower(%rip),%xmm3
+	subpd	%xmm3,%xmm0
+	addpd 	%xmm0,%xmm2		#r2 = r2 + (r - r1);
+
+	movapd 	%xmm3,%xmm0
+	movapd	%xmm2,%xmm1
+
+	mulpd 	.L__real_log10e_tail(%rip),%xmm2
+	mulpd 	.L__real_log10e_tail(%rip),%xmm0
+	mulpd 	.L__real_log10e_lead(%rip),%xmm1
+	mulpd 	.L__real_log10e_lead(%rip),%xmm3
+	addpd 	%xmm2,%xmm0
+	addpd 	%xmm1,%xmm0
+	addpd	%xmm3,%xmm0
+
+#      return r + r2;
+#	addpd	%xmm2,%xmm0
+	ret
+
+	.align	16
+.L__near_one1:
+	cmp	$3,%r9d
+	jnz		.L__n1nb1
+
+	movapd	p_x(%rsp),%xmm0
+	call	.Lboth_nearone
+	movlpd	%xmm0,(%rdi)
+	movhpd	%xmm0,8(%rdi)
+	jmp		.L__vlog2n
+
+	.align	16
+.L__n1nb1:
+	test	$1,%r9d
+	jz		.L__lnn12
+
+	movlpd	p_x(%rsp),%xmm0
+	call	.L__ln1
+	movlpd	%xmm0,(%rdi)
+
+.L__lnn12:
+	test	$2,%r9d		# second number?
+	jz		.L__lnn1e
+	movlpd	p_x+8(%rsp),%xmm0
+	call	.L__ln1
+	movlpd	%xmm0,8(%rdi)
+
+.L__lnn1e:
+	jmp		.L__vlog2n
+
+
+	.align	16
+.L__near_one2:
+	cmp	$3,%r9d
+	jnz		.L__n1nb2
+
+	movapd	p_x2(%rsp),%xmm0
+	call	.Lboth_nearone
+	movapd	%xmm0,%xmm7
+	jmp		.L__vlog4n
+
+	.align	16
+.L__n1nb2:
+	test	$1,%r9d
+	jz		.L__lnn22
+
+	movlpd	p_x2(%rsp),%xmm0
+	call	.L__ln1
+	movsd	%xmm0,%xmm7
+
+.L__lnn22:
+	test	$2,%r9d		# second number?
+	jz		.L__lnn2e
+	movlpd	p_x2+8(%rsp),%xmm0
+	call	.L__ln1
+	movlhps	%xmm0,%xmm7
+
+.L__lnn2e:
+	jmp		.L__vlog4n
+
+	.align	16
+
+.L__ln1:
+# saves 10 cycles
+#      r = x - 1.0;
+	movlpd	.L__real_two(%rip),%xmm2
+	subsd	.L__real_one(%rip),%xmm0	   # r
+#      u          = r / (2.0 + r);
+	addsd	%xmm0,%xmm2
+	movsd	%xmm0,%xmm1
+	divsd	%xmm2,%xmm1		# u
+	movlpd	.L__real_ca4(%rip),%xmm4	  #D
+	movlpd	.L__real_ca3(%rip),%xmm5	  #C
+#      correction = r * u;
+	movsd	%xmm0,%xmm6
+	mulsd	%xmm1,%xmm6		# correction
+#      u          = u + u;
+	addsd	%xmm1,%xmm1		#u
+	movsd	%xmm1,%xmm2
+	mulsd	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulsd	%xmm1,%xmm5		# Cu
+	movsd	%xmm1,%xmm3
+	mulsd	%xmm2,%xmm3		# u^3
+	mulsd	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulsd	%xmm3,%xmm4		#Du^3
+
+	addsd	.L__real_ca1(%rip),%xmm2	# +A
+	movsd	%xmm3,%xmm1
+	mulsd	%xmm1,%xmm1		# u^6
+	addsd	%xmm4,%xmm5		#Cu+Du3
+
+	mulsd	%xmm3,%xmm2		#u3(A+Bu2)
+	mulsd	%xmm5,%xmm1		#u6(Cu+Du3)
+	addsd	%xmm1,%xmm2
+	subsd	%xmm6,%xmm2		# -correction
+
+#	loge to log10
+	movsd 	%xmm0,%xmm3		#r1 = r
+	pand	.L__mask_lower(%rip),%xmm3
+	subsd	%xmm3,%xmm0
+	addsd 	%xmm0,%xmm2		#r2 = r2 + (r - r1);
+
+	movsd 	%xmm3,%xmm0
+	movsd	%xmm2,%xmm1
+
+	mulsd 	.L__real_log10e_tail(%rip),%xmm2
+	mulsd 	.L__real_log10e_tail(%rip),%xmm0
+	mulsd 	.L__real_log10e_lead(%rip),%xmm1
+	mulsd 	.L__real_log10e_lead(%rip),%xmm3
+	addsd 	%xmm2,%xmm0
+	addsd 	%xmm1,%xmm0
+	addsd	%xmm3,%xmm0
+
+#      return r + r2;
+#	addsd	%xmm2,%xmm0
+	ret
+
+	.align	16
+
+# at least one of the numbers was a nan or infinity
+.L__log_naninf:
+	test		$1,%r8d		# first number?
+	jz		.L__lninf2
+
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x(%rsp),%rdx
+	movlpd	p_x(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$2,%xmm1,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__lninf2:
+	test		$2,%r8d		# second number?
+	jz		.L__lninfe
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x+8(%rsp),%rdx
+	movlpd	p_x+8(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$0,%xmm0,%xmm1
+	movapd	%xmm1,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__lninfe:
+	jmp		.L__vlog1		# continue processing if not
+
+# at least one of the numbers was a nan or infinity
+.L__log_naninf2:
+	test		$1,%r10d		# first number?
+	jz		.L__lninf22
+
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm7,%xmm1		# save the inputs
+	mov		p_x2(%rsp),%rdx
+	movlpd	p_x2(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$2,%xmm7,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+	movapd	%xmm0,%xmm7
+
+.L__lninf22:
+	test		$2,%r10d		# second number?
+	jz		.L__lninfe2
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	mov		p_x2+8(%rsp),%rdx
+	movlpd	p_x2+8(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$0,%xmm0,%xmm7
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__lninfe2:
+	jmp		.L__vlog3		# continue processing if not
+
+# a subroutine to treat one number for nan/infinity
+# the number is expected in rdx and returned in the low
+# half of xmm0
+.L__lni:
+	mov		$0x0000FFFFFFFFFFFFF,%rax
+	test	%rax,%rdx
+	jnz		.L__lnan					# jump if mantissa not zero, so it's a NaN
+# inf
+	rcl		$1,%rdx
+	jnc		.L__lne2					# log(+inf) = inf
+# negative x
+	movlpd	.L__real_nan(%rip),%xmm0
+	ret
+
+#NaN
+.L__lnan:
+	mov		$0x00008000000000000,%rax	# convert to quiet
+	or		%rax,%rdx
+.L__lne:
+	movd	%rdx,%xmm0
+.L__lne2:
+	ret
+
+	.align	16
+
+# at least one of the numbers was a zero, a negative number, or both.
+.L__z_or_n:
+	test		$1,%r9d		# first number?
+	jz		.L__zn2
+
+	mov		%rax,p2_temp(%rsp)
+ 	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x(%rsp),%rax
+	call	.L__zni
+	shufpd	$2,%xmm1,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__zn2:
+	test		$2,%r9d		# second number?
+	jz		.L__zne
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x+8(%rsp),%rax
+	call	.L__zni
+	shufpd	$0,%xmm0,%xmm1
+	movapd	%xmm1,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__zne:
+	jmp		.L__vlog2
+
+.L__z_or_n2:
+	test		$1,%r11d		# first number?
+	jz		.L__zn22
+
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	mov		p_x2(%rsp),%rax
+	call	.L__zni
+	shufpd	$2,%xmm7,%xmm0
+	movapd	%xmm0,%xmm7
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__zn22:
+	test		$2,%r11d		# second number?
+	jz		.L__zne2
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	mov		p_x2+8(%rsp),%rax
+	call	.L__zni
+	shufpd	$0,%xmm0,%xmm7
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__zne2:
+	jmp		.L__vlog4
+# a subroutine to treat one number for zero or negative values
+# the number is expected in rax and returned in the low
+# half of xmm0
+.L__zni:
+	shl		$1,%rax
+	jnz		.L__zn_x		 # if just a carry, then must be negative
+	movlpd	.L__real_ninf(%rip),%xmm0  # C99 specs -inf for +-0
+	ret
+.L__zn_x:
+	movlpd	.L__real_nan(%rip),%xmm0
+	ret
+
+
+# we jump here when we have an odd number of log calls to make at the
+# end
+#  we assume that rdx is pointing at the next x array element,
+#  r8 at the next y array element.  The number of values left is in
+#  save_nv
+.L__vda_cleanup:
+        mov             save_nv(%rsp),%rax      # get number of values
+        test            %rax,%rax               # are there any values
+        jz              .L__finish         # exit if not
+
+	mov		save_xa(%rsp),%rsi
+	mov		save_ya(%rsp),%rdi
+
+# fill in a m128d with zeroes and the extra values and then make a recursive call.
+	xorpd		%xmm0,%xmm0
+	movlpd	%xmm0,p_x+8(%rsp)
+	movapd	%xmm0,p_x+16(%rsp)
+
+	mov		(%rsi),%rcx			# we know there's at least one
+	mov	 	%rcx,p_x(%rsp)
+	cmp		$2,%rax
+	jl		.L__vdacg
+
+	mov		8(%rsi),%rcx			# do the second value
+	mov	 	%rcx,p_x+8(%rsp)
+	cmp		$3,%rax
+	jl		.L__vdacg
+
+	mov		16(%rsi),%rcx			# do the third value
+	mov	 	%rcx,p_x+16(%rsp)
+
+.L__vdacg:
+	mov		$4,%rdi				# parameter for N
+	lea		p_x(%rsp),%rsi		# &x parameter
+	lea		p2_temp(%rsp),%rdx	# &y parameter
+	call	vrda_log10@PLT			# call recursively to compute four values
+
+# now copy the results to the destination array
+	mov		save_ya(%rsp),%rdi
+	mov		save_nv(%rsp),%rax	# get number of values
+	mov	 	p2_temp(%rsp),%rcx
+	mov		%rcx,(%rdi)			# we know there's at least one
+	cmp		$2,%rax
+	jl		.L__vdacgf
+
+	mov	 	p2_temp+8(%rsp),%rcx
+	mov		%rcx,8(%rdi)			# do the second value
+	cmp		$3,%rax
+	jl		.L__vdacgf
+
+	mov	 	p2_temp+16(%rsp),%rcx
+	mov		%rcx,16(%rdi)			# do the third value
+
+.L__vdacgf:
+	jmp		.L__finish
+
+	.data
+	.align	64
+
+.L__real_one:			.quad 0x03ff0000000000000	# 1.0
+				.quad 0x03ff0000000000000
+.L__real_two:			.quad 0x04000000000000000	# 2.0
+				.quad 0x04000000000000000
+.L__real_ninf:			.quad 0x0fff0000000000000	# -inf
+				.quad 0x0fff0000000000000
+.L__real_inf:			.quad 0x07ff0000000000000	# +inf
+				.quad 0x07ff0000000000000
+.L__real_nan:			.quad 0x07ff8000000000000	# NaN
+				.quad 0x07ff8000000000000
+
+.L__real_zero:			.quad 0x00000000000000000	# 0.0
+				.quad 0x00000000000000000
+
+.L__real_sign:			.quad 0x08000000000000000	# sign bit
+				.quad 0x08000000000000000
+.L__real_notsign:		.quad 0x07ffFFFFFFFFFFFFF	# ^sign bit
+				.quad 0x07ffFFFFFFFFFFFFF
+.L__real_threshold:		.quad 0x03FB082C000000000	# .064495086669921875 Threshold
+				.quad 0x03FB082C000000000
+.L__real_qnanbit:		.quad 0x00008000000000000	# quiet nan bit
+				.quad 0x00008000000000000
+.L__real_mant:			.quad 0x0000FFFFFFFFFFFFF	# mantissa bits
+				.quad 0x0000FFFFFFFFFFFFF
+.L__real_3f80000000000000:	.quad 0x03f80000000000000	# /* 0.0078125 = 1/128 */
+				.quad 0x03f80000000000000
+.L__mask_1023:			.quad 0x000000000000003ff	#
+				.quad 0x000000000000003ff
+.L__mask_040:			.quad 0x00000000000000040	#
+				.quad 0x00000000000000040
+.L__mask_001:			.quad 0x00000000000000001	#
+				.quad 0x00000000000000001
+
+.L__real_ca1:			.quad 0x03fb55555555554e6	# 8.33333333333317923934e-02
+				.quad 0x03fb55555555554e6
+.L__real_ca2:			.quad 0x03f89999999bac6d4	# 1.25000000037717509602e-02
+				.quad 0x03f89999999bac6d4
+.L__real_ca3:			.quad 0x03f62492307f1519f	# 2.23213998791944806202e-03
+				.quad 0x03f62492307f1519f
+.L__real_ca4:			.quad 0x03f3c8034c85dfff0	# 4.34887777707614552256e-04
+				.quad 0x03f3c8034c85dfff0
+
+.L__real_cb1:			.quad 0x03fb5555555555557	# 8.33333333333333593622e-02
+				.quad 0x03fb5555555555557
+.L__real_cb2:			.quad 0x03f89999999865ede	# 1.24999999978138668903e-02
+				.quad 0x03f89999999865ede
+.L__real_cb3:			.quad 0x03f6249423bd94741	# 2.23219810758559851206e-03
+				.quad 0x03f6249423bd94741
+.L__real_log2_lead:  		.quad 0x03fe62e42e0000000	# log2_lead	  6.93147122859954833984e-01
+				.quad 0x03fe62e42e0000000
+.L__real_log2_tail: 		.quad 0x03e6efa39ef35793c	# log2_tail	  5.76999904754328540596e-08
+				.quad 0x03e6efa39ef35793c
+
+.L__real_half:			.quad 0x03fe0000000000000	# 1/2
+				.quad 0x03fe0000000000000
+
+.L__real_log10e_lead:	.quad 0x03fdbcb7800000000	# log10e_lead 4.34293746948242187500e-01
+				.quad 0x03fdbcb7800000000
+.L__real_log10e_tail:	.quad 0x03ea8a93728719535	# log10e_tail 7.3495500964015109100644e-7
+				.quad 0x03ea8a93728719535
+
+.L__mask_lower:			.quad 0x0ffffffff00000000
+				.quad 0x0ffffffff00000000
+
+.L__np_ln_lead_table:
+	.quad	0x0000000000000000 		# 0.00000000000000000000e+00
+	.quad	0x3f8fc0a800000000		# 1.55041813850402832031e-02
+	.quad	0x3f9f829800000000		# 3.07716131210327148438e-02
+	.quad	0x3fa7745800000000		# 4.58095073699951171875e-02
+	.quad	0x3faf0a3000000000		# 6.06245994567871093750e-02
+	.quad	0x3fb341d700000000		# 7.52233862876892089844e-02
+	.quad	0x3fb6f0d200000000		# 8.96121263504028320312e-02
+	.quad	0x3fba926d00000000		# 1.03796780109405517578e-01
+	.quad	0x3fbe270700000000		# 1.17783010005950927734e-01
+	.quad	0x3fc0d77e00000000		# 1.31576299667358398438e-01
+	.quad	0x3fc2955280000000		# 1.45181953907012939453e-01
+	.quad	0x3fc44d2b00000000		# 1.58604979515075683594e-01
+	.quad	0x3fc5ff3000000000		# 1.71850204467773437500e-01
+	.quad	0x3fc7ab8900000000		# 1.84922337532043457031e-01
+	.quad	0x3fc9525a80000000		# 1.97825729846954345703e-01
+	.quad	0x3fcaf3c900000000		# 2.10564732551574707031e-01
+	.quad	0x3fcc8ff780000000		# 2.23143517971038818359e-01
+	.quad	0x3fce270700000000		# 2.35566020011901855469e-01
+	.quad	0x3fcfb91800000000		# 2.47836112976074218750e-01
+	.quad	0x3fd0a324c0000000		# 2.59957492351531982422e-01
+	.quad	0x3fd1675c80000000		# 2.71933674812316894531e-01
+	.quad	0x3fd22941c0000000		# 2.83768117427825927734e-01
+	.quad	0x3fd2e8e280000000		# 2.95464158058166503906e-01
+	.quad	0x3fd3a64c40000000		# 3.07025015354156494141e-01
+	.quad	0x3fd4618bc0000000		# 3.18453729152679443359e-01
+	.quad	0x3fd51aad80000000		# 3.29753279685974121094e-01
+	.quad	0x3fd5d1bd80000000		# 3.40926527976989746094e-01
+	.quad	0x3fd686c800000000		# 3.51976394653320312500e-01
+	.quad	0x3fd739d7c0000000		# 3.62905442714691162109e-01
+	.quad	0x3fd7eaf800000000		# 3.73716354370117187500e-01
+	.quad	0x3fd89a3380000000		# 3.84411692619323730469e-01
+	.quad	0x3fd9479400000000		# 3.94993782043457031250e-01
+	.quad	0x3fd9f323c0000000		# 4.05465066432952880859e-01
+	.quad	0x3fda9cec80000000		# 4.15827870368957519531e-01
+	.quad	0x3fdb44f740000000		# 4.26084339618682861328e-01
+	.quad	0x3fdbeb4d80000000		# 4.36236739158630371094e-01
+	.quad	0x3fdc8ff7c0000000		# 4.46287095546722412109e-01
+	.quad	0x3fdd32fe40000000		# 4.56237375736236572266e-01
+	.quad	0x3fddd46a00000000		# 4.66089725494384765625e-01
+	.quad	0x3fde744240000000		# 4.75845873355865478516e-01
+	.quad	0x3fdf128f40000000		# 4.85507786273956298828e-01
+	.quad	0x3fdfaf5880000000		# 4.95077252388000488281e-01
+	.quad	0x3fe02552a0000000		# 5.04556000232696533203e-01
+	.quad	0x3fe0723e40000000		# 5.13945698738098144531e-01
+	.quad	0x3fe0be72e0000000		# 5.23248136043548583984e-01
+	.quad	0x3fe109f380000000		# 5.32464742660522460938e-01
+	.quad	0x3fe154c3c0000000		# 5.41597247123718261719e-01
+	.quad	0x3fe19ee6a0000000		# 5.50647079944610595703e-01
+	.quad	0x3fe1e85f40000000		# 5.59615731239318847656e-01
+	.quad	0x3fe23130c0000000		# 5.68504691123962402344e-01
+	.quad	0x3fe2795e00000000		# 5.77315330505371093750e-01
+	.quad	0x3fe2c0e9e0000000		# 5.86049020290374755859e-01
+	.quad	0x3fe307d720000000		# 5.94707071781158447266e-01
+	.quad	0x3fe34e2880000000		# 6.03290796279907226562e-01
+	.quad	0x3fe393e0c0000000		# 6.11801505088806152344e-01
+	.quad	0x3fe3d90260000000		# 6.20240390300750732422e-01
+	.quad	0x3fe41d8fe0000000		# 6.28608644008636474609e-01
+	.quad	0x3fe4618bc0000000		# 6.36907458305358886719e-01
+	.quad	0x3fe4a4f840000000		# 6.45137906074523925781e-01
+	.quad	0x3fe4e7d800000000		# 6.53301239013671875000e-01
+	.quad	0x3fe52a2d20000000		# 6.61398470401763916016e-01
+	.quad	0x3fe56bf9c0000000		# 6.69430613517761230469e-01
+	.quad	0x3fe5ad4040000000		# 6.77398800849914550781e-01
+	.quad	0x3fe5ee02a0000000		# 6.85303986072540283203e-01
+	.quad	0x3fe62e42e0000000		# 6.93147122859954833984e-01
+	.quad 0					# for alignment
+
+.L__np_ln_tail_table:
+	.quad	0x00000000000000000 # 0	; 0.00000000000000000000e+00
+	.quad	0x03e361f807c79f3db		# 5.15092497094772879206e-09
+	.quad	0x03e6873c1980267c8		# 4.55457209735272790188e-08
+	.quad	0x03e5ec65b9f88c69e		# 2.86612990859791781788e-08
+	.quad	0x03e58022c54cc2f99		# 2.23596477332056055352e-08
+	.quad	0x03e62c37a3a125330		# 3.49498983167142274770e-08
+	.quad	0x03e615cad69737c93		# 3.23392843005887000414e-08
+	.quad	0x03e4d256ab1b285e9		# 1.35722380472479366661e-08
+	.quad	0x03e5b8abcb97a7aa2		# 2.56504325268044191098e-08
+	.quad	0x03e6f34239659a5dc		# 5.81213608741512136843e-08
+	.quad	0x03e6e07fd48d30177		# 5.59374849578288093334e-08
+	.quad	0x03e6b32df4799f4f6		# 5.06615629004996189970e-08
+	.quad	0x03e6c29e4f4f21cf8		# 5.24588857848400955725e-08
+	.quad	0x03e1086c848df1b59		# 9.61968535632653505972e-10
+	.quad	0x03e4cf456b4764130		# 1.34829655346594463137e-08
+	.quad	0x03e63a02ffcb63398		# 3.65557749306383026498e-08
+	.quad	0x03e61e6a6886b0976		# 3.33431709374069198903e-08
+	.quad	0x03e6b8abcb97a7aa2		# 5.13008650536088382197e-08
+	.quad	0x03e6b578f8aa35552		# 5.09285070380306053751e-08
+	.quad	0x03e6139c871afb9fc		# 3.20853940845502057341e-08
+	.quad	0x03e65d5d30701ce64		# 4.06713248643004200446e-08
+	.quad	0x03e6de7bcb2d12142		# 5.57028186706125221168e-08
+	.quad	0x03e6d708e984e1664		# 5.48356693724804282546e-08
+	.quad	0x03e556945e9c72f36		# 1.99407553679345001938e-08
+	.quad	0x03e20e2f613e85bda		# 1.96585517245087232086e-09
+	.quad	0x03e3cb7e0b42724f6		# 6.68649386072067321503e-09
+	.quad	0x03e6fac04e52846c7		# 5.89936034642113390002e-08
+	.quad	0x03e5e9b14aec442be		# 2.85038578721554472484e-08
+	.quad	0x03e6b5de8034e7126		# 5.09746772910284482606e-08
+	.quad	0x03e6dc157e1b259d3		# 5.54234668933210171467e-08
+	.quad	0x03e3b05096ad69c62		# 6.29100830926604004874e-09
+	.quad	0x03e5c2116faba4cdd		# 2.61974119468563937716e-08
+	.quad	0x03e665fcc25f95b47		# 4.16752115011186398935e-08
+	.quad	0x03e5a9a08498d4850		# 2.47747534460820790327e-08
+	.quad	0x03e6de647b1465f77		# 5.56922172017964209793e-08
+	.quad	0x03e5da71b7bf7861d		# 2.76162876992552906035e-08
+	.quad	0x03e3e6a6886b09760		# 7.08169709942321478061e-09
+	.quad	0x03e6f0075eab0ef64		# 5.77453510221151779025e-08
+	.quad	0x03e33071282fb989b		# 4.43021445893361960146e-09
+	.quad	0x03e60eb43c3f1bed2		# 3.15140984357495864573e-08
+	.quad	0x03e5faf06ecb35c84		# 2.95077445089736670973e-08
+	.quad	0x03e4ef1e63db35f68		# 1.44098510263167149349e-08
+	.quad	0x03e469743fb1a71a5		# 1.05196987538551827693e-08
+	.quad	0x03e6c1cdf404e5796		# 5.23641361722697546261e-08
+	.quad	0x03e4094aa0ada625e		# 7.72099925253243069458e-09
+	.quad	0x03e6e2d4c96fde3ec		# 5.62089493829364197156e-08
+	.quad	0x03e62f4d5e9a98f34		# 3.53090261098577946927e-08
+	.quad	0x03e6467c96ecc5cbe		# 3.80080516835568242269e-08
+	.quad	0x03e6e7040d03dec5a		# 5.66961038386146408282e-08
+	.quad	0x03e67bebf4282de36		# 4.42287063097349852717e-08
+	.quad	0x03e6289b11aeb783f		# 3.45294525105681104660e-08
+	.quad	0x03e5a891d1772f538		# 2.47132034530447431509e-08
+	.quad	0x03e634f10be1fb591		# 3.59655343422487209774e-08
+	.quad	0x03e6d9ce1d316eb93		# 5.51581770357780862071e-08
+	.quad	0x03e63562a19a9c442		# 3.60171867511861372793e-08
+	.quad	0x03e54e2adf548084c		# 1.94511067964296180547e-08
+	.quad	0x03e508ce55cc8c97a		# 1.54137376631349347838e-08
+	.quad	0x03e30e2f613e85bda		# 3.93171034490174464173e-09
+	.quad	0x03e6db03ebb0227bf		# 5.52990607758839766440e-08
+	.quad	0x03e61b75bb09cb098		# 3.29990737637586136511e-08
+	.quad	0x03e496f16abb9df22		# 1.18436010922446096216e-08
+	.quad	0x03e65b3f399411c62		# 4.04248680368301346709e-08
+	.quad	0x03e586b3e59f65355		# 2.27418915900284316293e-08
+	.quad	0x03e52482ceae1ac12		# 1.70263791333409206020e-08
+	.quad	0x03e6efa39ef35793c		# 5.76999904754328540596e-08
+	.quad 0					# for alignment
+
diff --git a/src/gas/vrdalog2.S b/src/gas/vrdalog2.S
new file mode 100644
index 0000000..0200f03
--- /dev/null
+++ b/src/gas/vrdalog2.S
@@ -0,0 +1,1003 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrdalog.s
+#
+# An array implementation of the log libm function.
+#
+# Prototype:
+#
+#    void vrda_log2(int n, double *x, double *y);
+#
+#   Computes the natural log of x.
+#   Returns proper C99 values, but may not raise status flags properly.
+#   Less than 1 ulp of error.  This version can compute logs in 44
+#   cycles with n <= 24
+#
+#
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+# define local variable storage offsets
+.equ	p_x,0			# temporary for error checking operation
+.equ	p_idx,0x010		# index storage
+.equ	p_xexp,0x020		# index storage
+
+.equ	p_x2,0x030		# temporary for error checking operation
+.equ	p_idx2,0x040		# index storage
+.equ	p_xexp2,0x050		# index storage
+
+.equ	save_xa,0x060		#qword
+.equ	save_ya,0x068		#qword
+.equ	save_nv,0x070		#qword
+.equ	p_iter,0x078		# qword	storage for number of loop iterations
+
+.equ	save_rbx,0x080		#qword
+
+
+.equ	p2_temp,0x090		# second temporary for get/put bits operation
+.equ	p2_temp1,0x0b0		# second temporary for exponent multiply
+
+.equ	p_n1,0x0c0		# temporary for near one check
+.equ	p_n12,0x0d0		# temporary for near one check
+
+
+.equ	stack_size,0x0e8
+
+	.weak vrda_log2_
+	.set vrda_log2_,__vrda_log2__
+	.weak vrda_log2__
+	.set vrda_log2__,__vrda_log2__
+
+# parameters are passed in by Linux as:
+# rdi - int n
+# rsi - double *x
+# rdx - double *y
+
+    .text
+    .align 16
+    .p2align 4,,15
+
+#x/* a FORTRAN subroutine implementation of array log
+#**     VRDA_LOG(N,X,Y)
+# C equivalent*/
+#void vrda_log2__(int * n, double *x, double *y)
+#{
+#       vrda_log2(*n,x,y);
+#}
+.globl __vrda_log2__
+    .type   __vrda_log2__,@function
+__vrda_log2__:
+    mov		(%rdi),%edi
+
+    .align 16
+    .p2align 4,,15
+.globl vrda_log2
+    .type   vrda_log2,@function
+vrda_log2:
+	sub		$stack_size,%rsp
+	mov		%rbx,save_rbx(%rsp)	# save rbx
+
+# save the arguments
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+	mov		%rdx,save_ya(%rsp)	# save y_array pointer
+#ifdef INTEGER64
+        mov             %rdi,%rax
+#else
+        mov             %edi,%eax
+        mov             %rax,%rdi
+#endif
+
+	mov		%rdi,save_nv(%rsp)	# save number of values
+# see if too few values to call the main loop
+	shr		$2,%rax			# get number of iterations
+	jz		.L__vda_cleanup		# jump if only single calls
+# prepare the iteration counts
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	shl		$2,%rax
+	sub		%rax,%rdi		# compute number of extra single calls
+	mov		%rdi,save_nv(%rsp)	# save number of left over values
+
+# In this second version, process the array 2 values at a time.
+
+.L__vda_top:
+# build the input _m128d
+	mov		save_xa(%rsp),%rsi	# get x_array pointer
+	movlpd	(%rsi),%xmm0
+	movhpd	8(%rsi),%xmm0
+	prefetch	64(%rsi)
+	add		$32,%rsi
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+
+                movlpd  -16(%rsi),%xmm7
+                movhpd  -8(%rsi),%xmm7
+
+# compute the logs
+
+##  if NaN or inf
+	movdqa	%xmm0,p_x(%rsp)	# save the input values
+
+#      /* Store the exponent of x in xexp and put
+#         f into the range [0.5,1) */
+
+	pxor	%xmm1,%xmm1
+	movdqa	%xmm0,%xmm3
+	psrlq	$52,%xmm3
+	psubq	.L__mask_1023(%rip),%xmm3
+	packssdw	%xmm1,%xmm3
+	cvtdq2pd	%xmm3,%xmm6			# xexp
+		movdqa	%xmm7,p_x2(%rsp)	# save the input values
+	movdqa	%xmm0,%xmm2
+	subpd	.L__real_one(%rip),%xmm2
+
+	movapd	%xmm6,p_xexp(%rsp)
+	andpd	.L__real_notsign(%rip),%xmm2
+	xor		%rax,%rax
+
+	movdqa	%xmm0,%xmm3
+	pand	.L__real_mant(%rip),%xmm3
+
+	cmppd	$1,.L__real_threshold(%rip),%xmm2
+	movmskpd	%xmm2,%ecx
+	movdqa	%xmm3,%xmm4
+	mov			%ecx,p_n1(%rsp)
+
+#/* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+	psrlq	$45,%xmm3
+	movdqa	%xmm3,%xmm2
+	psrlq	$1,%xmm3
+	paddq	.L__mask_040(%rip),%xmm3
+	pand	.L__mask_001(%rip),%xmm2
+	paddq	%xmm2,%xmm3
+
+	packssdw	%xmm1,%xmm3
+	cvtdq2pd	%xmm3,%xmm1
+		pxor	%xmm7,%xmm7
+		movdqa	p_x2(%rsp),%xmm2
+		movapd	p_x2(%rsp),%xmm5
+		psrlq	$52,%xmm2
+		psubq	.L__mask_1023(%rip),%xmm2
+		packssdw	%xmm7,%xmm2
+		subpd	.L__real_one(%rip),%xmm5
+		andpd	.L__real_notsign(%rip),%xmm5
+		cvtdq2pd	%xmm2,%xmm6			# xexp
+	xor		%rcx,%rcx
+		cmppd	$1,.L__real_threshold(%rip),%xmm5
+	movq	 %xmm3,p_idx(%rsp)
+
+# reduce and get u
+	por		.L__real_half(%rip),%xmm4
+	movdqa	%xmm4,%xmm2
+		movapd	%xmm6,p_xexp2(%rsp)
+
+	# do near one check
+		movmskpd	%xmm5,%edx
+		mov			%edx,p_n12(%rsp)
+
+	mulpd	.L__real_3f80000000000000(%rip),%xmm1				# f1 = index/128
+
+
+	lea		.L__np_ln_lead_table(%rip),%rdx
+	mov		p_idx(%rsp),%eax
+		movdqa	p_x2(%rsp),%xmm6
+
+	movapd	.L__real_half(%rip),%xmm5							# .5
+	subpd	%xmm1,%xmm2											# f2 = f - f1
+		pand	.L__real_mant(%rip),%xmm6
+	mulpd	%xmm2,%xmm5
+	addpd	%xmm5,%xmm1
+
+		movdqa	%xmm6,%xmm8
+		psrlq	$45,%xmm6
+		movdqa	%xmm6,%xmm4
+
+		psrlq	$1,%xmm6
+		paddq	.L__mask_040(%rip),%xmm6
+		pand	.L__mask_001(%rip),%xmm4
+		paddq	%xmm4,%xmm6
+# do error checking here for scheduling.  Saves a bunch of cycles as
+# compared to doing this at the start of the routine.
+##  if NaN or inf
+	movapd	%xmm0,%xmm3
+	andpd	.L__real_inf(%rip),%xmm3
+	cmppd	$0,.L__real_inf(%rip),%xmm3
+	movmskpd	%xmm3,%r8d
+		packssdw	%xmm7,%xmm6
+		por		.L__real_half(%rip),%xmm8
+		movq	 %xmm6,p_idx2(%rsp)
+		cvtdq2pd	%xmm6,%xmm9
+
+	cmppd	$2,.L__real_zero(%rip),%xmm0
+		mulpd	.L__real_3f80000000000000(%rip),%xmm9				# f1 = index/128
+	movmskpd	%xmm0,%r9d
+# delaying this divide helps, but moving the other one does not.
+# it was after the paddq
+	divpd	%xmm1,%xmm2				# u
+
+# compute the index into the log tables
+#
+
+        movlpd   -512(%rdx,%rax,8),%xmm0                # z1
+        mov             p_idx+4(%rsp),%ecx
+        movhpd   -512(%rdx,%rcx,8),%xmm0                # z1
+# solve for ln(1+u)
+	movapd	%xmm2,%xmm1				# u
+	mulpd	%xmm2,%xmm2				# u^2
+	movapd	%xmm2,%xmm5
+	movapd	.L__real_cb3(%rip),%xmm3
+	mulpd	%xmm2,%xmm3				#Cu2
+	mulpd	%xmm1,%xmm5				# u^3
+	addpd	.L__real_cb2(%rip),%xmm3 #B+Cu2
+
+	mulpd	%xmm5,%xmm2				# u^5
+	movapd	.L__real_log2e_lead(%rip),%xmm4
+
+	mulpd	.L__real_cb1(%rip),%xmm5 #Au3
+	addpd	%xmm5,%xmm1				# u+Au3
+	movapd	%xmm0,%xmm5				#z1 copy
+	mulpd	%xmm3,%xmm2				# u5(B+Cu2)
+	movapd	.L__real_log2e_tail(%rip),%xmm3
+	movapd	p_xexp(%rsp),%xmm6		# xexp
+	addpd	%xmm2,%xmm1				# poly
+# recombine
+	lea		.L__np_ln_tail_table(%rip),%rdx
+        movlpd   -512(%rdx,%rax,8),%xmm2                #z2     +=q
+        movhpd   -512(%rdx,%rcx,8),%xmm2                #z2     +=q
+		lea		.L__np_ln_lead_table(%rip),%rdx
+		mov		p_idx2(%rsp),%eax
+		mov		p_idx2+4(%rsp),%ecx
+	addpd	%xmm2,%xmm1	#z2
+	movapd	%xmm1,%xmm2 #z2 copy
+
+
+	mulpd	%xmm4,%xmm5
+	mulpd	%xmm4,%xmm1
+		movapd	.L__real_half(%rip),%xmm4							# .5
+		subpd	%xmm9,%xmm8											# f2 = f - f1
+		mulpd	%xmm8,%xmm4
+		addpd	%xmm4,%xmm9
+	mulpd	%xmm3,%xmm2	#z2*log2e_tail
+	mulpd	%xmm3,%xmm0	#z1*log2e_tail
+	addpd	%xmm6,%xmm5	#r1 = z1*log2e_lead + xexp
+	addpd	%xmm2,%xmm0	#z1*log2e_tail + z2*log2e_tail
+	addpd	%xmm1,%xmm0				#r2
+
+		divpd	%xmm9,%xmm8				# u
+		movapd	p_x2(%rsp),%xmm3
+		andpd	.L__real_inf(%rip),%xmm3
+		cmppd	$0,.L__real_inf(%rip),%xmm3
+		movmskpd	%xmm3,%r10d
+		movapd	p_x2(%rsp),%xmm6
+		cmppd	$2,.L__real_zero(%rip),%xmm6
+		movmskpd	%xmm6,%r11d
+
+# check for nans/infs
+	test		$3,%r8d
+	addpd	%xmm5,%xmm0
+	jnz		.L__log_naninf
+.L__vlog1:
+# check for negative numbers or zero
+	test		$3,%r9d
+	jnz		.L__z_or_n
+
+.L__vlog2:
+# store the result _m128d
+	mov		save_ya(%rsp),%rdi	# get y_array pointer
+	movlpd	%xmm0,(%rdi)
+	movhpd	 %xmm0,8(%rdi)
+
+	# It seems like a good idea to try and interleave
+	# even more of the following code sooner into the
+	# program.  But there were conflicts with the table
+	# index registers, making the problem difficult.
+	# After a lot of work in a branch of this file,
+	# I was not able to match the speed of this version.
+	# CodeAnalyst shows that there is lots of unused add
+	# pipe time around the divides, but the processor
+	# doesn't seem to be able to schedule in those slots.
+
+	        movlpd   -512(%rdx,%rax,8),%xmm7                #z2     +=q
+        	movhpd   -512(%rdx,%rcx,8),%xmm7                #z2     +=q
+
+# check for near one
+	mov			p_n1(%rsp),%r9d
+	test			$3,%r9d
+	jnz			.L__near_one1
+.L__vlog2n:
+
+	# solve for ln(1+u)
+		movapd	%xmm8,%xmm9				# u
+		mulpd	%xmm8,%xmm8				# u^2
+		movapd	%xmm8,%xmm5
+		movapd	.L__real_cb3(%rip),%xmm3
+		mulpd	%xmm8,%xmm3				#Cu2
+		mulpd	%xmm9,%xmm5				# u^3
+		addpd	.L__real_cb2(%rip),%xmm3 		#B+Cu2
+
+		mulpd	%xmm5,%xmm8				# u^5
+		movapd	.L__real_log2e_lead(%rip),%xmm4
+
+		mulpd	.L__real_cb1(%rip),%xmm5 		#Au3
+		addpd	%xmm5,%xmm9				# u+Au3
+		movapd	%xmm7,%xmm5				#z1 copy
+		mulpd	%xmm3,%xmm8				# u5(B+Cu2)
+		movapd	.L__real_log2e_tail(%rip),%xmm3
+		movapd	p_xexp2(%rsp),%xmm6			# xexp
+		addpd	%xmm8,%xmm9				# poly
+	# recombine
+		lea		.L__np_ln_tail_table(%rip),%rdx
+	        movlpd   -512(%rdx,%rax,8),%xmm2                #z2     +=q
+        	movhpd   -512(%rdx,%rcx,8),%xmm2                #z2     +=q
+		addpd	%xmm2,%xmm9		#z2
+		movapd	%xmm9,%xmm2		#z2 copy
+
+		mulpd	%xmm4,%xmm5	#z1*log2e_lead
+		mulpd	%xmm4,%xmm9	#z2*log2e_lead
+		mulpd	%xmm3,%xmm2	#z2*log2e_tail
+		mulpd	%xmm3,%xmm7	#z1*log2e_tail
+		addpd	%xmm6,%xmm5	#r1 = z1*log2e_lead + xexp
+		addpd	%xmm2,%xmm7	#z1*log2e_tail + z2*log2e_tail
+
+
+		addpd	%xmm9,%xmm7				#r2
+
+	# check for nans/infs
+		test		$3,%r10d
+		addpd	%xmm5,%xmm7
+		jnz		.L__log_naninf2
+.L__vlog3:
+# check for negative numbers or zero
+		test		$3,%r11d
+		jnz		.L__z_or_n2
+
+.L__vlog4:
+	mov			p_n12(%rsp),%r9d
+	test			$3,%r9d
+	jnz			.L__near_one2
+
+.L__vlog4n:
+
+
+#__vda_bottom2:
+
+	prefetch	64(%rdi)
+	add		$32,%rdi
+	mov		%rdi,save_ya(%rsp)	# save y_array pointer
+
+# store the result _m128d
+		movlpd	%xmm7,-16(%rdi)
+		movhpd	%xmm7,-8(%rdi)
+
+	mov		p_iter(%rsp),%rax	# get number of iterations
+	sub		$1,%rax
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	jnz		.L__vda_top
+
+
+# see if we need to do any extras
+	mov		save_nv(%rsp),%rax	# get number of values
+	test		%rax,%rax
+	jnz		.L__vda_cleanup
+
+
+.L__finish:
+	mov		save_rbx(%rsp),%rbx		# restore rbx
+	add		$stack_size,%rsp
+	ret
+
+	.align	16
+.Lboth_nearone:
+# saves 10 cycles
+#      r = x - 1.0;
+	movapd	.L__real_two(%rip),%xmm2
+	subpd	.L__real_one(%rip),%xmm0	   # r
+#      u          = r / (2.0 + r);
+	addpd	%xmm0,%xmm2
+	movapd	%xmm0,%xmm1
+	divpd	%xmm2,%xmm1		# u
+	movapd	.L__real_ca4(%rip),%xmm4	  #D
+	movapd	.L__real_ca3(%rip),%xmm5	  #C
+#      correction = r * u;
+	movapd	%xmm0,%xmm6
+	mulpd	%xmm1,%xmm6		# correction
+#      u          = u + u;
+	addpd	%xmm1,%xmm1		#u
+	movapd	%xmm1,%xmm2
+	mulpd	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulpd	%xmm1,%xmm5		# Cu
+	movapd	%xmm1,%xmm3
+	mulpd	%xmm2,%xmm3		# u^3
+	mulpd	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulpd	%xmm3,%xmm4		#Du^3
+
+	addpd	.L__real_ca1(%rip),%xmm2	# +A
+	movapd	%xmm3,%xmm1
+	mulpd	%xmm1,%xmm1		# u^6
+	addpd	%xmm4,%xmm5		#Cu+Du3
+
+	mulpd	%xmm3,%xmm2		#u3(A+Bu2)
+	mulpd	%xmm5,%xmm1		#u6(Cu+Du3)
+	addpd	%xmm1,%xmm2
+	subpd	%xmm6,%xmm2		# -correction
+
+#	loge to log2
+	movapd 	%xmm0,%xmm3		#r1 = r
+	pand	.L__mask_lower(%rip),%xmm3
+	subpd	%xmm3,%xmm0
+	addpd 	%xmm0,%xmm2		#r2 = r2 + (r - r1);
+
+	movapd 	%xmm3,%xmm0
+	movapd	%xmm2,%xmm1
+
+	mulpd 	.L__real_log2e_tail(%rip),%xmm2
+	mulpd 	.L__real_log2e_tail(%rip),%xmm0
+	mulpd 	.L__real_log2e_lead(%rip),%xmm1
+	mulpd 	.L__real_log2e_lead(%rip),%xmm3
+	addpd 	%xmm2,%xmm0
+	addpd 	%xmm1,%xmm0
+	addpd	%xmm3,%xmm0
+#      return r + r2;
+#	addpd	%xmm2,%xmm0
+	ret
+
+	.align	16
+.L__near_one1:
+	cmp	$3,%r9d
+	jnz		.L__n1nb1
+
+	movapd	p_x(%rsp),%xmm0
+	call	.Lboth_nearone
+	movlpd	%xmm0,(%rdi)
+	movhpd	%xmm0,8(%rdi)
+	jmp		.L__vlog2n
+
+	.align	16
+.L__n1nb1:
+	test	$1,%r9d
+	jz		.L__lnn12
+
+	movlpd	p_x(%rsp),%xmm0
+	call	.L__ln1
+	movlpd	%xmm0,(%rdi)
+
+.L__lnn12:
+	test	$2,%r9d		# second number?
+	jz		.L__lnn1e
+	movlpd	p_x+8(%rsp),%xmm0
+	call	.L__ln1
+	movlpd	%xmm0,8(%rdi)
+
+.L__lnn1e:
+	jmp		.L__vlog2n
+
+
+	.align	16
+.L__near_one2:
+	cmp	$3,%r9d
+	jnz		.L__n1nb2
+
+	movapd	p_x2(%rsp),%xmm0
+	call	.Lboth_nearone
+	movapd	%xmm0,%xmm7
+	jmp		.L__vlog4n
+
+	.align	16
+.L__n1nb2:
+	test	$1,%r9d
+	jz		.L__lnn22
+
+	movlpd	p_x2(%rsp),%xmm0
+	call	.L__ln1
+	movsd	%xmm0,%xmm7
+
+.L__lnn22:
+	test	$2,%r9d		# second number?
+	jz		.L__lnn2e
+	movlpd	p_x2+8(%rsp),%xmm0
+	call	.L__ln1
+	movlhps	%xmm0,%xmm7
+
+.L__lnn2e:
+	jmp		.L__vlog4n
+
+	.align	16
+
+.L__ln1:
+# saves 10 cycles
+#      r = x - 1.0;
+	movlpd	.L__real_two(%rip),%xmm2
+	subsd	.L__real_one(%rip),%xmm0	   # r
+#      u          = r / (2.0 + r);
+	addsd	%xmm0,%xmm2
+	movsd	%xmm0,%xmm1
+	divsd	%xmm2,%xmm1		# u
+	movlpd	.L__real_ca4(%rip),%xmm4	  #D
+	movlpd	.L__real_ca3(%rip),%xmm5	  #C
+#      correction = r * u;
+	movsd	%xmm0,%xmm6
+	mulsd	%xmm1,%xmm6		# correction
+#      u          = u + u;
+	addsd	%xmm1,%xmm1		#u
+	movsd	%xmm1,%xmm2
+	mulsd	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulsd	%xmm1,%xmm5		# Cu
+	movsd	%xmm1,%xmm3
+	mulsd	%xmm2,%xmm3		# u^3
+	mulsd	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulsd	%xmm3,%xmm4		#Du^3
+
+	addsd	.L__real_ca1(%rip),%xmm2	# +A
+	movsd	%xmm3,%xmm1
+	mulsd	%xmm1,%xmm1		# u^6
+	addsd	%xmm4,%xmm5		#Cu+Du3
+
+	mulsd	%xmm3,%xmm2		#u3(A+Bu2)
+	mulsd	%xmm5,%xmm1		#u6(Cu+Du3)
+	addsd	%xmm1,%xmm2
+	subsd	%xmm6,%xmm2		# -correction
+
+#	loge to log2
+	movsd 	%xmm0,%xmm3		#r1 = r
+	pand	.L__mask_lower(%rip),%xmm3
+	subsd	%xmm3,%xmm0
+	addsd 	%xmm0,%xmm2		#r2 = r2 + (r - r1);
+
+	movsd 	%xmm3,%xmm0
+	movsd	%xmm2,%xmm1
+
+	mulsd 	.L__real_log2e_tail(%rip),%xmm2
+	mulsd 	.L__real_log2e_tail(%rip),%xmm0
+	mulsd 	.L__real_log2e_lead(%rip),%xmm1
+	mulsd 	.L__real_log2e_lead(%rip),%xmm3
+	addsd 	%xmm2,%xmm0
+	addsd 	%xmm1,%xmm0
+	addsd	%xmm3,%xmm0
+
+#      return r + r2;
+#	addsd	%xmm2,%xmm0
+	ret
+
+	.align	16
+
+# at least one of the numbers was a nan or infinity
+.L__log_naninf:
+	test		$1,%r8d		# first number?
+	jz		.L__lninf2
+
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x(%rsp),%rdx
+	movlpd	p_x(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$2,%xmm1,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__lninf2:
+	test		$2,%r8d		# second number?
+	jz		.L__lninfe
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x+8(%rsp),%rdx
+	movlpd	p_x+8(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$0,%xmm0,%xmm1
+	movapd	%xmm1,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__lninfe:
+	jmp		.L__vlog1		# continue processing if not
+
+# at least one of the numbers was a nan or infinity
+.L__log_naninf2:
+	test		$1,%r10d		# first number?
+	jz		.L__lninf22
+
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm7,%xmm1		# save the inputs
+	mov		p_x2(%rsp),%rdx
+	movlpd	p_x2(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$2,%xmm7,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+	movapd	%xmm0,%xmm7
+
+.L__lninf22:
+	test		$2,%r10d		# second number?
+	jz		.L__lninfe2
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	mov		p_x2+8(%rsp),%rdx
+	movlpd	p_x2+8(%rsp),%xmm0
+	call	.L__lni
+	shufpd	$0,%xmm0,%xmm7
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__lninfe2:
+	jmp		.L__vlog3		# continue processing if not
+
+# a subroutine to treat one number for nan/infinity
+# the number is expected in rdx and returned in the low
+# half of xmm0
+.L__lni:
+	mov		$0x0000FFFFFFFFFFFFF,%rax
+	test	%rax,%rdx
+	jnz		.L__lnan					# jump if mantissa not zero, so it's a NaN
+# inf
+	rcl		$1,%rdx
+	jnc		.L__lne2					# log(+inf) = inf
+# negative x
+	movlpd	.L__real_nan(%rip),%xmm0
+	ret
+
+#NaN
+.L__lnan:
+	mov		$0x00008000000000000,%rax	# convert to quiet
+	or		%rax,%rdx
+.L__lne:
+	movd	%rdx,%xmm0
+.L__lne2:
+	ret
+
+	.align	16
+
+# at least one of the numbers was a zero, a negative number, or both.
+.L__z_or_n:
+	test		$1,%r9d		# first number?
+	jz		.L__zn2
+
+	mov		%rax,p2_temp(%rsp)
+ 	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x(%rsp),%rax
+	call	.L__zni
+	shufpd	$2,%xmm1,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__zn2:
+	test		$2,%r9d		# second number?
+	jz		.L__zne
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	movapd	%xmm0,%xmm1		# save the inputs
+	mov		p_x+8(%rsp),%rax
+	call	.L__zni
+	shufpd	$0,%xmm0,%xmm1
+	movapd	%xmm1,%xmm0
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__zne:
+	jmp		.L__vlog2
+
+.L__z_or_n2:
+	test		$1,%r11d		# first number?
+	jz		.L__zn22
+
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	mov		p_x2(%rsp),%rax
+	call	.L__zni
+	shufpd	$2,%xmm7,%xmm0
+	movapd	%xmm0,%xmm7
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__zn22:
+	test		$2,%r11d		# second number?
+	jz		.L__zne2
+	mov		%rax,p2_temp(%rsp)
+	mov		%rdx,p2_temp+8(%rsp)
+	mov		p_x2+8(%rsp),%rax
+	call	.L__zni
+	shufpd	$0,%xmm0,%xmm7
+	mov		p2_temp(%rsp),%rax
+	mov		p2_temp+8(%rsp),%rdx
+
+.L__zne2:
+	jmp		.L__vlog4
+# a subroutine to treat one number for zero or negative values
+# the number is expected in rax and returned in the low
+# half of xmm0
+.L__zni:
+	shl		$1,%rax
+	jnz		.L__zn_x		 # if just a carry, then must be negative
+	movlpd	.L__real_ninf(%rip),%xmm0  # C99 specs -inf for +-0
+	ret
+.L__zn_x:
+	movlpd	.L__real_nan(%rip),%xmm0
+	ret
+
+
+# we jump here when we have an odd number of log calls to make at the
+# end
+#  we assume that rdx is pointing at the next x array element,
+#  r8 at the next y array element.  The number of values left is in
+#  save_nv
+.L__vda_cleanup:
+        mov             save_nv(%rsp),%rax      # get number of values
+        test            %rax,%rax               # are there any values
+        jz              .L__finish         # exit if not
+
+	mov		save_xa(%rsp),%rsi
+	mov		save_ya(%rsp),%rdi
+
+# fill in a m128d with zeroes and the extra values and then make a recursive call.
+	xorpd		%xmm0,%xmm0
+	movlpd	%xmm0,p_x+8(%rsp)
+	movapd	%xmm0,p_x+16(%rsp)
+
+	mov		(%rsi),%rcx			# we know there's at least one
+	mov	 	%rcx,p_x(%rsp)
+	cmp		$2,%rax
+	jl		.L__vdacg
+
+	mov		8(%rsi),%rcx			# do the second value
+	mov	 	%rcx,p_x+8(%rsp)
+	cmp		$3,%rax
+	jl		.L__vdacg
+
+	mov		16(%rsi),%rcx			# do the third value
+	mov	 	%rcx,p_x+16(%rsp)
+
+.L__vdacg:
+	mov		$4,%rdi				# parameter for N
+	lea		p_x(%rsp),%rsi		# &x parameter
+	lea		p2_temp(%rsp),%rdx	# &y parameter
+	call		vrda_log2@PLT		# call recursively to compute four values
+
+# now copy the results to the destination array
+	mov		save_ya(%rsp),%rdi
+	mov		save_nv(%rsp),%rax	# get number of values
+	mov	 	p2_temp(%rsp),%rcx
+	mov		%rcx,(%rdi)			# we know there's at least one
+	cmp		$2,%rax
+	jl		.L__vdacgf
+
+	mov	 	p2_temp+8(%rsp),%rcx
+	mov		%rcx,8(%rdi)			# do the second value
+	cmp		$3,%rax
+	jl		.L__vdacgf
+
+	mov	 	p2_temp+16(%rsp),%rcx
+	mov		%rcx,16(%rdi)			# do the third value
+
+.L__vdacgf:
+	jmp		.L__finish
+
+	.data
+	.align	64
+
+.L__real_one:			.quad 0x03ff0000000000000	# 1.0
+				.quad 0x03ff0000000000000
+.L__real_two:			.quad 0x04000000000000000	# 2.0
+				.quad 0x04000000000000000
+.L__real_ninf:			.quad 0x0fff0000000000000	# -inf
+				.quad 0x0fff0000000000000
+.L__real_inf:			.quad 0x07ff0000000000000	# +inf
+				.quad 0x07ff0000000000000
+.L__real_nan:			.quad 0x07ff8000000000000	# NaN
+				.quad 0x07ff8000000000000
+
+.L__real_zero:			.quad 0x00000000000000000	# 0.0
+				.quad 0x00000000000000000
+
+.L__real_sign:			.quad 0x08000000000000000	# sign bit
+				.quad 0x08000000000000000
+.L__real_notsign:		.quad 0x07ffFFFFFFFFFFFFF	# ^sign bit
+				.quad 0x07ffFFFFFFFFFFFFF
+.L__real_threshold:		.quad 0x03F9EB85000000000	# .03
+				.quad 0x03F9EB85000000000
+.L__real_qnanbit:		.quad 0x00008000000000000	# quiet nan bit
+				.quad 0x00008000000000000
+.L__real_mant:			.quad 0x0000FFFFFFFFFFFFF	# mantissa bits
+				.quad 0x0000FFFFFFFFFFFFF
+.L__real_3f80000000000000:	.quad 0x03f80000000000000	# /* 0.0078125 = 1/128 */
+				.quad 0x03f80000000000000
+.L__mask_1023:			.quad 0x000000000000003ff	#
+				.quad 0x000000000000003ff
+.L__mask_040:			.quad 0x00000000000000040	#
+				.quad 0x00000000000000040
+.L__mask_001:			.quad 0x00000000000000001	#
+				.quad 0x00000000000000001
+
+.L__real_ca1:			.quad 0x03fb55555555554e6	# 8.33333333333317923934e-02
+				.quad 0x03fb55555555554e6
+.L__real_ca2:			.quad 0x03f89999999bac6d4	# 1.25000000037717509602e-02
+				.quad 0x03f89999999bac6d4
+.L__real_ca3:			.quad 0x03f62492307f1519f	# 2.23213998791944806202e-03
+				.quad 0x03f62492307f1519f
+.L__real_ca4:			.quad 0x03f3c8034c85dfff0	# 4.34887777707614552256e-04
+				.quad 0x03f3c8034c85dfff0
+
+.L__real_cb1:			.quad 0x03fb5555555555557	# 8.33333333333333593622e-02
+				.quad 0x03fb5555555555557
+.L__real_cb2:			.quad 0x03f89999999865ede	# 1.24999999978138668903e-02
+				.quad 0x03f89999999865ede
+.L__real_cb3:			.quad 0x03f6249423bd94741	# 2.23219810758559851206e-03
+				.quad 0x03f6249423bd94741
+.L__real_log2_lead:  		.quad 0x03fe62e42e0000000	# log2_lead	  6.93147122859954833984e-01
+				.quad 0x03fe62e42e0000000
+.L__real_log2_tail: 		.quad 0x03e6efa39ef35793c	# log2_tail	  5.76999904754328540596e-08
+				.quad 0x03e6efa39ef35793c
+
+.L__real_half:			.quad 0x03fe0000000000000	# 1/2
+						.quad 0x03fe0000000000000
+.L__real_log2e_lead:	.quad 0x03FF7154400000000	# log2e_lead	  1.44269180297851562500E+00
+						.quad 0x03FF7154400000000
+.L__real_log2e_tail :	.quad 0x03ECB295C17F0BBBE	# log2e_tail	  3.23791044778235969970E-06
+						.quad 0x03ECB295C17F0BBBE
+.L__mask_lower:			.quad 0x0ffffffff00000000
+						.quad 0x0ffffffff00000000
+
+.L__np_ln_lead_table:
+	.quad	0x0000000000000000 		# 0.00000000000000000000e+00
+	.quad	0x3f8fc0a800000000		# 1.55041813850402832031e-02
+	.quad	0x3f9f829800000000		# 3.07716131210327148438e-02
+	.quad	0x3fa7745800000000		# 4.58095073699951171875e-02
+	.quad	0x3faf0a3000000000		# 6.06245994567871093750e-02
+	.quad	0x3fb341d700000000		# 7.52233862876892089844e-02
+	.quad	0x3fb6f0d200000000		# 8.96121263504028320312e-02
+	.quad	0x3fba926d00000000		# 1.03796780109405517578e-01
+	.quad	0x3fbe270700000000		# 1.17783010005950927734e-01
+	.quad	0x3fc0d77e00000000		# 1.31576299667358398438e-01
+	.quad	0x3fc2955280000000		# 1.45181953907012939453e-01
+	.quad	0x3fc44d2b00000000		# 1.58604979515075683594e-01
+	.quad	0x3fc5ff3000000000		# 1.71850204467773437500e-01
+	.quad	0x3fc7ab8900000000		# 1.84922337532043457031e-01
+	.quad	0x3fc9525a80000000		# 1.97825729846954345703e-01
+	.quad	0x3fcaf3c900000000		# 2.10564732551574707031e-01
+	.quad	0x3fcc8ff780000000		# 2.23143517971038818359e-01
+	.quad	0x3fce270700000000		# 2.35566020011901855469e-01
+	.quad	0x3fcfb91800000000		# 2.47836112976074218750e-01
+	.quad	0x3fd0a324c0000000		# 2.59957492351531982422e-01
+	.quad	0x3fd1675c80000000		# 2.71933674812316894531e-01
+	.quad	0x3fd22941c0000000		# 2.83768117427825927734e-01
+	.quad	0x3fd2e8e280000000		# 2.95464158058166503906e-01
+	.quad	0x3fd3a64c40000000		# 3.07025015354156494141e-01
+	.quad	0x3fd4618bc0000000		# 3.18453729152679443359e-01
+	.quad	0x3fd51aad80000000		# 3.29753279685974121094e-01
+	.quad	0x3fd5d1bd80000000		# 3.40926527976989746094e-01
+	.quad	0x3fd686c800000000		# 3.51976394653320312500e-01
+	.quad	0x3fd739d7c0000000		# 3.62905442714691162109e-01
+	.quad	0x3fd7eaf800000000		# 3.73716354370117187500e-01
+	.quad	0x3fd89a3380000000		# 3.84411692619323730469e-01
+	.quad	0x3fd9479400000000		# 3.94993782043457031250e-01
+	.quad	0x3fd9f323c0000000		# 4.05465066432952880859e-01
+	.quad	0x3fda9cec80000000		# 4.15827870368957519531e-01
+	.quad	0x3fdb44f740000000		# 4.26084339618682861328e-01
+	.quad	0x3fdbeb4d80000000		# 4.36236739158630371094e-01
+	.quad	0x3fdc8ff7c0000000		# 4.46287095546722412109e-01
+	.quad	0x3fdd32fe40000000		# 4.56237375736236572266e-01
+	.quad	0x3fddd46a00000000		# 4.66089725494384765625e-01
+	.quad	0x3fde744240000000		# 4.75845873355865478516e-01
+	.quad	0x3fdf128f40000000		# 4.85507786273956298828e-01
+	.quad	0x3fdfaf5880000000		# 4.95077252388000488281e-01
+	.quad	0x3fe02552a0000000		# 5.04556000232696533203e-01
+	.quad	0x3fe0723e40000000		# 5.13945698738098144531e-01
+	.quad	0x3fe0be72e0000000		# 5.23248136043548583984e-01
+	.quad	0x3fe109f380000000		# 5.32464742660522460938e-01
+	.quad	0x3fe154c3c0000000		# 5.41597247123718261719e-01
+	.quad	0x3fe19ee6a0000000		# 5.50647079944610595703e-01
+	.quad	0x3fe1e85f40000000		# 5.59615731239318847656e-01
+	.quad	0x3fe23130c0000000		# 5.68504691123962402344e-01
+	.quad	0x3fe2795e00000000		# 5.77315330505371093750e-01
+	.quad	0x3fe2c0e9e0000000		# 5.86049020290374755859e-01
+	.quad	0x3fe307d720000000		# 5.94707071781158447266e-01
+	.quad	0x3fe34e2880000000		# 6.03290796279907226562e-01
+	.quad	0x3fe393e0c0000000		# 6.11801505088806152344e-01
+	.quad	0x3fe3d90260000000		# 6.20240390300750732422e-01
+	.quad	0x3fe41d8fe0000000		# 6.28608644008636474609e-01
+	.quad	0x3fe4618bc0000000		# 6.36907458305358886719e-01
+	.quad	0x3fe4a4f840000000		# 6.45137906074523925781e-01
+	.quad	0x3fe4e7d800000000		# 6.53301239013671875000e-01
+	.quad	0x3fe52a2d20000000		# 6.61398470401763916016e-01
+	.quad	0x3fe56bf9c0000000		# 6.69430613517761230469e-01
+	.quad	0x3fe5ad4040000000		# 6.77398800849914550781e-01
+	.quad	0x3fe5ee02a0000000		# 6.85303986072540283203e-01
+	.quad	0x3fe62e42e0000000		# 6.93147122859954833984e-01
+	.quad 0					# for alignment
+
+.L__np_ln_tail_table:
+	.quad	0x00000000000000000 # 0	; 0.00000000000000000000e+00
+	.quad	0x03e361f807c79f3db		# 5.15092497094772879206e-09
+	.quad	0x03e6873c1980267c8		# 4.55457209735272790188e-08
+	.quad	0x03e5ec65b9f88c69e		# 2.86612990859791781788e-08
+	.quad	0x03e58022c54cc2f99		# 2.23596477332056055352e-08
+	.quad	0x03e62c37a3a125330		# 3.49498983167142274770e-08
+	.quad	0x03e615cad69737c93		# 3.23392843005887000414e-08
+	.quad	0x03e4d256ab1b285e9		# 1.35722380472479366661e-08
+	.quad	0x03e5b8abcb97a7aa2		# 2.56504325268044191098e-08
+	.quad	0x03e6f34239659a5dc		# 5.81213608741512136843e-08
+	.quad	0x03e6e07fd48d30177		# 5.59374849578288093334e-08
+	.quad	0x03e6b32df4799f4f6		# 5.06615629004996189970e-08
+	.quad	0x03e6c29e4f4f21cf8		# 5.24588857848400955725e-08
+	.quad	0x03e1086c848df1b59		# 9.61968535632653505972e-10
+	.quad	0x03e4cf456b4764130		# 1.34829655346594463137e-08
+	.quad	0x03e63a02ffcb63398		# 3.65557749306383026498e-08
+	.quad	0x03e61e6a6886b0976		# 3.33431709374069198903e-08
+	.quad	0x03e6b8abcb97a7aa2		# 5.13008650536088382197e-08
+	.quad	0x03e6b578f8aa35552		# 5.09285070380306053751e-08
+	.quad	0x03e6139c871afb9fc		# 3.20853940845502057341e-08
+	.quad	0x03e65d5d30701ce64		# 4.06713248643004200446e-08
+	.quad	0x03e6de7bcb2d12142		# 5.57028186706125221168e-08
+	.quad	0x03e6d708e984e1664		# 5.48356693724804282546e-08
+	.quad	0x03e556945e9c72f36		# 1.99407553679345001938e-08
+	.quad	0x03e20e2f613e85bda		# 1.96585517245087232086e-09
+	.quad	0x03e3cb7e0b42724f6		# 6.68649386072067321503e-09
+	.quad	0x03e6fac04e52846c7		# 5.89936034642113390002e-08
+	.quad	0x03e5e9b14aec442be		# 2.85038578721554472484e-08
+	.quad	0x03e6b5de8034e7126		# 5.09746772910284482606e-08
+	.quad	0x03e6dc157e1b259d3		# 5.54234668933210171467e-08
+	.quad	0x03e3b05096ad69c62		# 6.29100830926604004874e-09
+	.quad	0x03e5c2116faba4cdd		# 2.61974119468563937716e-08
+	.quad	0x03e665fcc25f95b47		# 4.16752115011186398935e-08
+	.quad	0x03e5a9a08498d4850		# 2.47747534460820790327e-08
+	.quad	0x03e6de647b1465f77		# 5.56922172017964209793e-08
+	.quad	0x03e5da71b7bf7861d		# 2.76162876992552906035e-08
+	.quad	0x03e3e6a6886b09760		# 7.08169709942321478061e-09
+	.quad	0x03e6f0075eab0ef64		# 5.77453510221151779025e-08
+	.quad	0x03e33071282fb989b		# 4.43021445893361960146e-09
+	.quad	0x03e60eb43c3f1bed2		# 3.15140984357495864573e-08
+	.quad	0x03e5faf06ecb35c84		# 2.95077445089736670973e-08
+	.quad	0x03e4ef1e63db35f68		# 1.44098510263167149349e-08
+	.quad	0x03e469743fb1a71a5		# 1.05196987538551827693e-08
+	.quad	0x03e6c1cdf404e5796		# 5.23641361722697546261e-08
+	.quad	0x03e4094aa0ada625e		# 7.72099925253243069458e-09
+	.quad	0x03e6e2d4c96fde3ec		# 5.62089493829364197156e-08
+	.quad	0x03e62f4d5e9a98f34		# 3.53090261098577946927e-08
+	.quad	0x03e6467c96ecc5cbe		# 3.80080516835568242269e-08
+	.quad	0x03e6e7040d03dec5a		# 5.66961038386146408282e-08
+	.quad	0x03e67bebf4282de36		# 4.42287063097349852717e-08
+	.quad	0x03e6289b11aeb783f		# 3.45294525105681104660e-08
+	.quad	0x03e5a891d1772f538		# 2.47132034530447431509e-08
+	.quad	0x03e634f10be1fb591		# 3.59655343422487209774e-08
+	.quad	0x03e6d9ce1d316eb93		# 5.51581770357780862071e-08
+	.quad	0x03e63562a19a9c442		# 3.60171867511861372793e-08
+	.quad	0x03e54e2adf548084c		# 1.94511067964296180547e-08
+	.quad	0x03e508ce55cc8c97a		# 1.54137376631349347838e-08
+	.quad	0x03e30e2f613e85bda		# 3.93171034490174464173e-09
+	.quad	0x03e6db03ebb0227bf		# 5.52990607758839766440e-08
+	.quad	0x03e61b75bb09cb098		# 3.29990737637586136511e-08
+	.quad	0x03e496f16abb9df22		# 1.18436010922446096216e-08
+	.quad	0x03e65b3f399411c62		# 4.04248680368301346709e-08
+	.quad	0x03e586b3e59f65355		# 2.27418915900284316293e-08
+	.quad	0x03e52482ceae1ac12		# 1.70263791333409206020e-08
+	.quad	0x03e6efa39ef35793c		# 5.76999904754328540596e-08
+	.quad 0					# for alignment
+
diff --git a/src/gas/vrdalogr.S b/src/gas/vrdalogr.S
new file mode 100644
index 0000000..4064fb3
--- /dev/null
+++ b/src/gas/vrdalogr.S
@@ -0,0 +1,2428 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrdalog.asm
+#
+# An array implementation of the log libm function.
+#
+# Prototype:
+#
+#    void vrda_logr(int n, double *x, double *y);
+#
+#   Computes the natural log of x.
+# A reduced precision routine.   Uses the intel novel reduction technique
+# with frcpa.  Also uses only 3 polynomial terms to acheive52-18= 34 significant digits
+#
+#   This specialized routine does not handle negative numbers, 0, NaNs, or infin ity.
+#   This routine is not C99 compliant
+#   This version can compute logs in 26
+#   cycles with n <= 24
+#
+#
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+# define local variable storage offsets
+.equ	p_x,0			# temporary for error checking operation
+
+.equ	p_x2,0x030		# temporary for error checking operation
+
+.equ	save_xa,0x060		#qword
+.equ	save_ya,0x068		#qword
+.equ	save_nv,0x070		#qword
+.equ	p_iter,0x078		# qword	storage for number of loop iterations
+
+.equ	save_rbx,0x080		#qword
+.equ	save_rdi,0x088		#qword
+
+.equ	save_rsi,0x090		#qword
+
+
+
+.equ	p2_temp,0x0e0		# second temporary for get/put bits operation
+.equ	p2_temp1,0x0f0		# second temporary for exponent multiply
+
+
+
+.equ	stack_size,0x0118
+
+        .weak vrda_logr_
+        .set vrda_logr_,__vrda_logr__
+        .weak vrda_logr__
+        .set vrda_logr__,__vrda_logr__
+
+# parameters are passed in by Linux as:
+# rdi - int n
+# rsi - double *x
+# rdx - double *y
+
+    .text
+    .align 16
+    .p2align 4,,15
+
+#/* a FORTRAN subroutine implementation of array log
+#**     VRDA_LOGR(N,X,Y)
+#** C equivalent
+#*/
+#void vrda_logr_(int * n, double *x, double *y)
+#{
+#       vrda_logr(*n,x,y);
+#}
+.globl __vrda_logr__
+    .type   __vrda_logr__,@function
+__vrda_logr__:
+    mov         (%rdi),%edi
+
+    .align 16
+    .p2align 4,,15
+.globl vrda_logr
+    .type   vrda_logr,@function
+vrda_logr:
+        sub             $stack_size,%rsp
+        mov             %rbx,save_rbx(%rsp)     # save rbx
+
+# save the arguments
+        mov             %rsi,save_xa(%rsp)      # save x_array pointer
+        mov             %rdx,save_ya(%rsp)      # save y_array pointer
+#ifdef INTEGER64
+        mov             %rdi,%rax
+#else
+        mov             %edi,%eax
+        mov             %rax,%rdi
+#endif
+
+        mov             %rdi,save_nv(%rsp)      # save number of values
+# see if too few values to call the main loop
+	shr		$2,%rax			# get number of iterations
+	jz		.L__vda_cleanup		# jump if only single calls
+# prepare the iteration counts
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	shl		$2,%rax
+	sub		%rax,%rdi		# compute number of extra single calls
+	mov		%rdi,save_nv(%rsp)	# save number of left over values
+
+# In this second version, process the array 2 values at a time.
+
+.L__vda_top:
+# build the input _m128d
+	mov		save_xa(%rsp),%rsi	# get x_array pointer
+	movlpd	(%rsi),%xmm0
+	movhpd	8(%rsi),%xmm0
+	prefetch	64(%rsi)
+	add		$32,%rsi
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+
+		movlpd	-16(%rsi),%xmm1
+		movhpd	-8(%rsi),%xmm1
+# compute the logs
+
+##  if NaN or inf
+	movdqa	%xmm0,p_x(%rsp)	# save the input values
+
+# use the  algorithm referenced in the itanic trancendental paper.
+
+# reduction
+#  compute r = x frcpa(x) - 1
+	movdqa	%xmm0,%xmm8
+	movdqa	%xmm1,%xmm9
+
+	call	__vrd4_frcpa@PLT
+	movdqa	%xmm8,%xmm4
+		movdqa	%xmm9,%xmm7
+# invert the exponent
+	psllq	$1,%xmm8
+		psllq	$1,%xmm9
+	mulpd	%xmm0,%xmm4				# r
+		mulpd	%xmm1,%xmm7			# r
+	movdqa	%xmm8,%xmm5
+	paddq	.L__mask_rup(%rip),%xmm8
+	psrlq	$53,%xmm8
+		movdqa	%xmm9,%xmm6
+		paddq	.L__mask_rup(%rip),%xmm6
+		psrlq	$53,%xmm6
+	psubq	.L__mask_3ff(%rip),%xmm8
+		psubq	.L__mask_3ff(%rip),%xmm6
+	pshufd	$0x058,%xmm8,%xmm8
+		pshufd	$0x058,%xmm6,%xmm6
+
+
+	subpd	.L__real_one(%rip),%xmm4
+		subpd	.L__real_one(%rip),%xmm7
+
+	cvtdq2pd	%xmm8,%xmm0		#N
+		cvtdq2pd	%xmm6,%xmm1		#N
+
+# compute index for table lookup. if 1/2 bit set, increment the index+exponent
+	psrlq	$42,%xmm5
+		psrlq	$42,%xmm9
+	paddq	.L__int_one(%rip),%xmm5
+		paddq	.L__int_one(%rip),%xmm9
+	psrlq	$1,%xmm5
+		psrlq	$1,%xmm9
+	pand	.L__mask_3ff(%rip),%xmm5
+		pand	.L__mask_3ff(%rip),%xmm9
+	psllq	$1,%xmm5
+		psllq	$1,%xmm9
+
+	movdqa	%xmm5,p_x(%rsp)	# move the indexes to a memory location
+		movdqa	%xmm9,p_x2(%rsp)
+
+
+	movapd	.L__real_third(%rip),%xmm3
+		movdqa	%xmm3,%xmm5
+	movapd	%xmm4,%xmm2
+		movapd	%xmm7,%xmm8
+
+# approximation
+#  compute the polynomial
+#   p(r) = p1r^2+p2r^3+p3r^4+p4r^5
+
+	mulpd	%xmm4,%xmm2			#r^2
+		mulpd	%xmm7,%xmm8			#r^2
+
+# eliminating the 4th and 5th terms gets us to 8000ulps, or 53-16=37 significant digits
+# The routine runs in 60 cycles.
+	mulpd	%xmm4,%xmm3			# 1/3r
+		mulpd	%xmm7,%xmm5			# 1/3r
+# lookup the f(k) term
+	lea		.L__np_lnf_table(%rip),%rdx
+	mov		p_x(%rsp),%rcx
+	mov		p_x+8(%rsp),%r9
+	movlpd		(%rdx,%rcx,8),%xmm6  	# lookup
+	movhpd		(%rdx,%r9,8),%xmm6  	# lookup
+
+	addpd	.L__real_half(%rip),%xmm3  # p2 + p3r
+		addpd	.L__real_half(%rip),%xmm5  # p2 + p3r
+
+		mov		p_x2(%rsp),%rcx
+		mov		p_x2+8(%rsp),%r9
+		movlpd		(%rdx,%rcx,8),%xmm9  	# lookup
+		movhpd		(%rdx,%r9,8),%xmm9  	# lookup
+
+	mulpd	%xmm3,%xmm2			# r2(p2 + p3r)
+		mulpd	%xmm5,%xmm8			# r2(p2 + p3r)
+	addpd	%xmm4,%xmm2			# +r
+		addpd	%xmm7,%xmm8			# +r
+
+
+#	reconstruction
+#  compute ln(x) = T + r + p(r) where
+#   T =	N*ln(2)+ln(1/frcpa(x)) via tab of ln(1/frcpa(y)), where y = 1 +	k/256, 0<=k<=255
+
+	mulpd	.L__real_log2(%rip),%xmm0	 # compute  N*__real_log2
+		mulpd	.L__real_log2(%rip),%xmm1	 # compute  N*__real_log2
+	addpd	%xmm6,%xmm2	# add the new mantissas
+		addpd	%xmm9,%xmm8	# add the new mantissas
+	addpd	%xmm2,%xmm0
+		addpd	%xmm8,%xmm1
+# store the result _m128d
+	mov		save_ya(%rsp),%rdi	# get y_array pointer
+	movlpd	%xmm0,(%rdi)
+	movhpd	  %xmm0,8(%rdi)
+
+
+	prefetch	64(%rdi)
+	add		$32,%rdi
+	mov		%rdi,save_ya(%rsp)	# save y_array pointer
+
+# store the result _m128d
+		movlpd	%xmm1,-16(%rdi)
+		movhpd	%xmm1,-8(%rdi)
+
+	mov		p_iter(%rsp),%rax	# get number of iterations
+	sub		$1,%rax
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	jnz		.L__vda_top
+
+
+# see if we need to do any extras
+	mov		save_nv(%rsp),%rax	# get number of values
+	test	%rax,%rax
+	jnz		.L__vda_cleanup
+
+
+.L__finish:
+	mov		save_rbx(%rsp),%rbx		# restore rbx
+	add		$stack_size,%rsp
+	ret
+
+# we jump here when we have an odd number of log calls to make at the
+# end
+#  we assume that rdx is pointing at the next x array element,
+#  r8 at the next y array element.  The number of values left is in
+#  save_nv
+.L__vda_cleanup:
+        mov             save_nv(%rsp),%rax      # get number of values
+        test            %rax,%rax               # are there any values
+        jz              .L__finish		# exit if not
+
+	mov		save_xa(%rsp),%rsi
+	mov		save_ya(%rsp),%rdi
+
+# fill in a m128d with zeroes and the extra values and then make a recursive call.
+	xorpd		%xmm0,%xmm0
+        movlpd  %xmm0,p_x+8(%rsp)
+        movapd  %xmm0,p_x+16(%rsp)
+
+	mov		(%rsi),%rcx			# we know there's at least one
+	mov	 	%rcx,p_x(%rsp)
+	cmp		$2,%rax
+	jl		.L__vdacg
+
+	mov		8(%rsi),%rcx			# do the second value
+	mov	 	%rcx,p_x+8(%rsp)
+	cmp		$3,%rax
+	jl		.L__vdacg
+
+	mov		16(%rsi),%rcx			# do the third value
+	mov	 	%rcx,p_x+16(%rsp)
+
+.L__vdacg:
+	mov		$4,%rcx				# parameter for N
+	lea		p_x(%rsp),%rdx	# &x parameter
+	lea		p2_temp(%rsp),%r8	# &y parameter
+	call	vrda_logr@PLT				# call recursively to compute four values
+
+# now copy the results to the destination array
+	mov		save_ya(%rsp),%rdi
+	mov		save_nv(%rsp),%rax	# get number of values
+	mov	 	p2_temp(%rsp),%rcx
+	mov		%rcx,(%rdi)			# we know there's at least one
+	cmp		$2,%rax
+	jl		.L__vdacgf
+
+	mov	 	p2_temp+8(%rsp),%rcx
+	mov		%rcx,8(%rdi)			# do the second value
+	cmp		$3,%rax
+	jl		.L__vdacgf
+
+	mov	 	p2_temp+16(%rsp),%rcx
+	mov		%rcx,16(%rdi)			# do the third value
+
+.L__vdacgf:
+	jmp		.L__finish
+
+        .data
+        .align  64
+
+.L__real_one:		.quad 0x03ff0000000000000	# 1.0
+			.quad 0x03ff0000000000000
+
+.L__real_half:		.quad 0x0bfe0000000000000	# 1/2
+			.quad 0x0bfe0000000000000
+.L__real_third:		.quad 0x03fd5555555555555	# 1/3
+			.quad 0x03fd5555555555555
+.L__real_fourth:	.quad 0x0bfd0000000000000	# 1/4
+			.quad 0x0bfd0000000000000
+.L__real_fifth:		.quad 0x03fc999999999999a	# 1/5
+			.quad 0x03fc999999999999a
+.L__real_sixth:		.quad 0x0bfc5555555555555	# 1/6
+			.quad 0x0bfc5555555555555
+
+.L__real_log2:	        .quad 0x03FE62E42FEFA39EF  # 0.693147182465
+		        .quad 0x03FE62E42FEFA39EF
+
+.L__mask_3ff:		.quad 0x000000000000003ff	#
+			.quad 0x000000000000003ff
+
+.L__mask_rup:           .quad 0x0000003fffffffffe
+                        .quad 0x0000003fffffffffe
+
+.L__int_one:		.quad 0x00000000000000001
+			.quad 0x00000000000000001
+
+
+
+.L__mask_10bits:	.quad 0x000000000000003ff
+			.quad 0x000000000000003ff
+
+.L__mask_expext:	.quad 0x000000000003ff000
+			.quad 0x000000000003ff000
+
+.L__mask_expext2:	.quad 0x000000000003ff800
+			.quad 0x000000000003ff800
+
+
+
+
+.L__np_lnf_table:
+#log table Program - logtab.c
+#Built Jan 18 2006  09:51:57
+#Compiler version  1400
+
+    .quad 0x00000000000000000  # 0.000000000000 0
+    .quad 0x00000000000000000
+    .quad 0x03F50020055655885  # 0.000977039648 1
+    .quad 0x03F50020055655885
+    .quad 0x03F60040155D5881E  # 0.001955034836 2
+    .quad 0x03F60040155D5881E
+    .quad 0x03F6809048289860A  # 0.002933987435 3
+    .quad 0x03F6809048289860A
+    .quad 0x03F70080559588B25  # 0.003913899321 4
+    .quad 0x03F70080559588B25
+    .quad 0x03F740C8A7478788D  # 0.004894772377 5
+    .quad 0x03F740C8A7478788D
+    .quad 0x03F78121214586B02  # 0.005876608489 6
+    .quad 0x03F78121214586B02
+    .quad 0x03F7C189CBB0E283F  # 0.006859409551 7
+    .quad 0x03F7C189CBB0E283F
+    .quad 0x03F8010157588DE69  # 0.007843177461 8
+    .quad 0x03F8010157588DE69
+    .quad 0x03F82145E939EF1BC  # 0.008827914124 9
+    .quad 0x03F82145E939EF1BC
+    .quad 0x03F83D8896A83D7A8  # 0.009690354884 10
+    .quad 0x03F83D8896A83D7A8
+    .quad 0x03F85DDC705054DFF  # 0.010676913110 11
+    .quad 0x03F85DDC705054DFF
+    .quad 0x03F87E38762CA0C6D  # 0.011664445593 12
+    .quad 0x03F87E38762CA0C6D
+    .quad 0x03F89E9CAC6007563  # 0.012652954261 13
+    .quad 0x03F89E9CAC6007563
+    .quad 0x03F8BF091710935A4  # 0.013642441046 14
+    .quad 0x03F8BF091710935A4
+    .quad 0x03F8DF7DBA6777895  # 0.014632907884 15
+    .quad 0x03F8DF7DBA6777895
+    .quad 0x03F8FBEA8B13C03F9  # 0.015500371846 16
+    .quad 0x03F8FBEA8B13C03F9
+    .quad 0x03F90E3751F24F45C  # 0.016492681528 17
+    .quad 0x03F90E3751F24F45C
+    .quad 0x03F91E7D80B1FBF4C  # 0.017485976867 18
+    .quad 0x03F91E7D80B1FBF4C
+    .quad 0x03F92CBE4F6CC56C3  # 0.018355920375 19
+    .quad 0x03F92CBE4F6CC56C3
+    .quad 0x03F93D0C443D7258C  # 0.019351069108 20
+    .quad 0x03F93D0C443D7258C
+    .quad 0x03F94D5E6176ACC89  # 0.020347209148 21
+    .quad 0x03F94D5E6176ACC89
+    .quad 0x03F95DB4A937DEF10  # 0.021344342472 22
+    .quad 0x03F95DB4A937DEF10
+    .quad 0x03F96C039490E37F4  # 0.022217650494 23
+    .quad 0x03F96C039490E37F4
+    .quad 0x03F97C61B1CF5DED7  # 0.023216651576 24
+    .quad 0x03F97C61B1CF5DED7
+    .quad 0x03F98AB77B3FD6EAD  # 0.024091596947 25
+    .quad 0x03F98AB77B3FD6EAD
+    .quad 0x03F99B1D75828E780  # 0.025092472797 26
+    .quad 0x03F99B1D75828E780
+    .quad 0x03F9AB87A478CB7CB  # 0.026094351403 27
+    .quad 0x03F9AB87A478CB7CB
+    .quad 0x03F9B9E8027E1916F  # 0.026971819338 28
+    .quad 0x03F9B9E8027E1916F
+    .quad 0x03F9CA5A1A18613E6  # 0.027975583538 29
+    .quad 0x03F9CA5A1A18613E6
+    .quad 0x03F9D8C1670325921  # 0.028854704473 30
+    .quad 0x03F9D8C1670325921
+    .quad 0x03F9E93B6EE41F674  # 0.029860361378 31
+    .quad 0x03F9E93B6EE41F674
+    .quad 0x03F9F7A9B16782855  # 0.030741141554 32
+    .quad 0x03F9F7A9B16782855
+    .quad 0x03FA0415D89E74440  # 0.031748698315 33
+    .quad 0x03FA0415D89E74440
+    .quad 0x03FA0C58FA19DFAAB  # 0.032757271269 34
+    .quad 0x03FA0C58FA19DFAAB
+    .quad 0x03FA139577CC41C1A  # 0.033640607815 35
+    .quad 0x03FA139577CC41C1A
+    .quad 0x03FA1AD398C6CD57C  # 0.034524725334 36
+    .quad 0x03FA1AD398C6CD57C
+    .quad 0x03FA231C9C40E204E  # 0.035536103423 37
+    .quad 0x03FA231C9C40E204E
+    .quad 0x03FA2A5E4231CF7BD  # 0.036421899115 38
+    .quad 0x03FA2A5E4231CF7BD
+    .quad 0x03FA32AB4D4C59CB0  # 0.037435198758 39
+    .quad 0x03FA32AB4D4C59CB0
+    .quad 0x03FA39F07BA0EBD5A  # 0.038322679007 40
+    .quad 0x03FA39F07BA0EBD5A
+    .quad 0x03FA424192495D571  # 0.039337907520 41
+    .quad 0x03FA424192495D571
+    .quad 0x03FA498A4C73DA65D  # 0.040227078744 42
+    .quad 0x03FA498A4C73DA65D
+    .quad 0x03FA50D4AF75CA86F  # 0.041117041297 43
+    .quad 0x03FA50D4AF75CA86F
+    .quad 0x03FA592BBC15215BC  # 0.042135112141 44
+    .quad 0x03FA592BBC15215BC
+    .quad 0x03FA6079B00423FF6  # 0.043026775152 45
+    .quad 0x03FA6079B00423FF6
+    .quad 0x03FA67C94F2D4BB65  # 0.043919233935 46
+    .quad 0x03FA67C94F2D4BB65
+    .quad 0x03FA70265A550E77B  # 0.044940163069 47
+    .quad 0x03FA70265A550E77B
+    .quad 0x03FA77798F8D6DFDC  # 0.045834331871 48
+    .quad 0x03FA77798F8D6DFDC
+    .quad 0x03FA7ECE7267CD123  # 0.046729300926 49
+    .quad 0x03FA7ECE7267CD123
+    .quad 0x03FA873184BC09586  # 0.047753104446 50
+    .quad 0x03FA873184BC09586
+    .quad 0x03FA8E8A02D2E3175  # 0.048649793163 51
+    .quad 0x03FA8E8A02D2E3175
+    .quad 0x03FA95E430F8CE456  # 0.049547286652 52
+    .quad 0x03FA95E430F8CE456
+    .quad 0x03FA9D400FF482586  # 0.050445586359 53
+    .quad 0x03FA9D400FF482586
+    .quad 0x03FAA5AB21CB34A9E  # 0.051473203662 54
+    .quad 0x03FAA5AB21CB34A9E
+    .quad 0x03FAAD0AA2E784EF4  # 0.052373235867 55
+    .quad 0x03FAAD0AA2E784EF4
+    .quad 0x03FAB46BD74DA76A0  # 0.053274078860 56
+    .quad 0x03FAB46BD74DA76A0
+    .quad 0x03FABBCEBFC68F424  # 0.054175734102 57
+    .quad 0x03FABBCEBFC68F424
+    .quad 0x03FAC3335D1BBAE4D  # 0.055078203060 58
+    .quad 0x03FAC3335D1BBAE4D
+    .quad 0x03FACBA87200EB8F1  # 0.056110594428 59
+    .quad 0x03FACBA87200EB8F1
+    .quad 0x03FAD310BA20455A2  # 0.057014812019 60
+    .quad 0x03FAD310BA20455A2
+    .quad 0x03FADA7AB998B77ED  # 0.057919847959 61
+    .quad 0x03FADA7AB998B77ED
+    .quad 0x03FAE1E6713606CFB  # 0.058825703731 62
+    .quad 0x03FAE1E6713606CFB
+    .quad 0x03FAE953E1C48603A  # 0.059732380822 63
+    .quad 0x03FAE953E1C48603A
+    .quad 0x03FAF0C30C1116351  # 0.060639880722 64
+    .quad 0x03FAF0C30C1116351
+    .quad 0x03FAF833F0E927711  # 0.061548204926 65
+    .quad 0x03FAF833F0E927711
+    .quad 0x03FAFFA6911AB9309  # 0.062457354934 66
+    .quad 0x03FAFFA6911AB9309
+    .quad 0x03FB038D76BA2D737  # 0.063367332247 67
+    .quad 0x03FB038D76BA2D737
+    .quad 0x03FB0748836296412  # 0.064278138373 68
+    .quad 0x03FB0748836296412
+    .quad 0x03FB0B046EEE6F7A4  # 0.065189774824 69
+    .quad 0x03FB0B046EEE6F7A4
+    .quad 0x03FB0EC139C5DA5FD  # 0.066102243114 70
+    .quad 0x03FB0EC139C5DA5FD
+    .quad 0x03FB127EE451413A8  # 0.067015544762 71
+    .quad 0x03FB127EE451413A8
+    .quad 0x03FB163D6EF9579FC  # 0.067929681294 72
+    .quad 0x03FB163D6EF9579FC
+    .quad 0x03FB19FCDA271ABC0  # 0.068844654235 73
+    .quad 0x03FB19FCDA271ABC0
+    .quad 0x03FB1DBD2643D1912  # 0.069760465119 74
+    .quad 0x03FB1DBD2643D1912
+    .quad 0x03FB217E53B90D3CE  # 0.070677115481 75
+    .quad 0x03FB217E53B90D3CE
+    .quad 0x03FB254062F0A9417  # 0.071594606862 76
+    .quad 0x03FB254062F0A9417
+    .quad 0x03FB29035454CBCB0  # 0.072512940806 77
+    .quad 0x03FB29035454CBCB0
+    .quad 0x03FB2CC7284FE5F1A  # 0.073432118863 78
+    .quad 0x03FB2CC7284FE5F1A
+    .quad 0x03FB308BDF4CB4062  # 0.074352142586 79
+    .quad 0x03FB308BDF4CB4062
+    .quad 0x03FB345179B63DD3F  # 0.075273013532 80
+    .quad 0x03FB345179B63DD3F
+    .quad 0x03FB3817F7F7D6EAB  # 0.076194733263 81
+    .quad 0x03FB3817F7F7D6EAB
+    .quad 0x03FB3BDF5A7D1EE5E  # 0.077117303344 82
+    .quad 0x03FB3BDF5A7D1EE5E
+    .quad 0x03FB3F1D405CE86D3  # 0.077908755701 83
+    .quad 0x03FB3F1D405CE86D3
+    .quad 0x03FB42E64BEC266E4  # 0.078832909176 84
+    .quad 0x03FB42E64BEC266E4
+    .quad 0x03FB46B03CF437BC4  # 0.079757917501 85
+    .quad 0x03FB46B03CF437BC4
+    .quad 0x03FB4A7B13E1E3E65  # 0.080683782259 86
+    .quad 0x03FB4A7B13E1E3E65
+    .quad 0x03FB4E46D1223FE84  # 0.081610505036 87
+    .quad 0x03FB4E46D1223FE84
+    .quad 0x03FB52137522AE732  # 0.082538087426 88
+    .quad 0x03FB52137522AE732
+    .quad 0x03FB5555DE434F2A0  # 0.083333843436 89
+    .quad 0x03FB5555DE434F2A0
+    .quad 0x03FB59242FF043D34  # 0.084263026485 90
+    .quad 0x03FB59242FF043D34
+    .quad 0x03FB5CF36997817B2  # 0.085193073719 91
+    .quad 0x03FB5CF36997817B2
+    .quad 0x03FB60C38BA799459  # 0.086123986746 92
+    .quad 0x03FB60C38BA799459
+    .quad 0x03FB6408F471C82A2  # 0.086922602521 93
+    .quad 0x03FB6408F471C82A2
+    .quad 0x03FB67DAC7466CB96  # 0.087855127734 94
+    .quad 0x03FB67DAC7466CB96
+    .quad 0x03FB6BAD83C1883BA  # 0.088788523361 95
+    .quad 0x03FB6BAD83C1883BA
+    .quad 0x03FB6EF528C056A2D  # 0.089589270768 96
+    .quad 0x03FB6EF528C056A2D
+    .quad 0x03FB72C9985035BB1  # 0.090524287199 97
+    .quad 0x03FB72C9985035BB1
+    .quad 0x03FB769EF2C6B5688  # 0.091460178704 98
+    .quad 0x03FB769EF2C6B5688
+    .quad 0x03FB79E8D70A364C6  # 0.092263069152 99
+    .quad 0x03FB79E8D70A364C6
+    .quad 0x03FB7DBFE6EA733FE  # 0.093200590148 100
+    .quad 0x03FB7DBFE6EA733FE
+    .quad 0x03FB8197E2F40E3F0  # 0.094138990914 101
+    .quad 0x03FB8197E2F40E3F0
+    .quad 0x03FB84E40992A4804  # 0.094944035906 102
+    .quad 0x03FB84E40992A4804
+    .quad 0x03FB88BDBD5FC66D2  # 0.095884074919 103
+    .quad 0x03FB88BDBD5FC66D2
+    .quad 0x03FB8C985E9B9EC7E  # 0.096824998438 104
+    .quad 0x03FB8C985E9B9EC7E
+    .quad 0x03FB8FE6CAB20E979  # 0.097632209567 105
+    .quad 0x03FB8FE6CAB20E979
+    .quad 0x03FB93C3261014C65  # 0.098574780162 106
+    .quad 0x03FB93C3261014C65
+    .quad 0x03FB97130DC9235DE  # 0.099383405543 107
+    .quad 0x03FB97130DC9235DE
+    .quad 0x03FB9AF124D64C623  # 0.100327628989 108
+    .quad 0x03FB9AF124D64C623
+    .quad 0x03FB9E4289871E964  # 0.101137673586 109
+    .quad 0x03FB9E4289871E964
+    .quad 0x03FBA2225DD276FCB  # 0.102083555691 110
+    .quad 0x03FBA2225DD276FCB
+    .quad 0x03FBA57540D1FE441  # 0.102895024494 111
+    .quad 0x03FBA57540D1FE441
+    .quad 0x03FBA956D3ECADE60  # 0.103842571097 112
+    .quad 0x03FBA956D3ECADE60
+    .quad 0x03FBACAB3693AB9C0  # 0.104655469123 113
+    .quad 0x03FBACAB3693AB9C0
+    .quad 0x03FBB08E8A10F96F4  # 0.105604686090 114
+    .quad 0x03FBB08E8A10F96F4
+    .quad 0x03FBB3E46DBA02181  # 0.106419018383 115
+    .quad 0x03FBB3E46DBA02181
+    .quad 0x03FBB7C9832F58018  # 0.107369911615 116
+    .quad 0x03FBB7C9832F58018
+    .quad 0x03FBBB20E936D6976  # 0.108185683244 117
+    .quad 0x03FBBB20E936D6976
+    .quad 0x03FBBF07C23BC54EA  # 0.109138258671 118
+    .quad 0x03FBBF07C23BC54EA
+    .quad 0x03FBC260ABFFFE972  # 0.109955474734 119
+    .quad 0x03FBC260ABFFFE972
+    .quad 0x03FBC6494A2E418A0  # 0.110909738320 120
+    .quad 0x03FBC6494A2E418A0
+    .quad 0x03FBC9A3B90F57748  # 0.111728403941 121
+    .quad 0x03FBC9A3B90F57748
+    .quad 0x03FBCCFEDBFEE13A8  # 0.112547740324 122
+    .quad 0x03FBCCFEDBFEE13A8
+    .quad 0x03FBD0EA1362CDBFC  # 0.113504482008 123
+    .quad 0x03FBD0EA1362CDBFC
+    .quad 0x03FBD446BD753D433  # 0.114325275488 124
+    .quad 0x03FBD446BD753D433
+    .quad 0x03FBD7A41C8627307  # 0.115146743223 125
+    .quad 0x03FBD7A41C8627307
+    .quad 0x03FBDB91F09680DF9  # 0.116105975911 126
+    .quad 0x03FBDB91F09680DF9
+    .quad 0x03FBDEF0D8D466DBB  # 0.116928908339 127
+    .quad 0x03FBDEF0D8D466DBB
+    .quad 0x03FBE2507702AF03B  # 0.117752518544 128
+    .quad 0x03FBE2507702AF03B
+    .quad 0x03FBE640EB3D2B411  # 0.118714255240 129
+    .quad 0x03FBE640EB3D2B411
+    .quad 0x03FBE9A214A69DD58  # 0.119539337795 130
+    .quad 0x03FBE9A214A69DD58
+    .quad 0x03FBED03F4F440969  # 0.120365101673 131
+    .quad 0x03FBED03F4F440969
+    .quad 0x03FBF0F70CDD992E4  # 0.121329355484 132
+    .quad 0x03FBF0F70CDD992E4
+    .quad 0x03FBF45A7A78B7C3B  # 0.122156599431 133
+    .quad 0x03FBF45A7A78B7C3B
+    .quad 0x03FBF7BE9FEDBFDED  # 0.122984528276 134
+    .quad 0x03FBF7BE9FEDBFDED
+    .quad 0x03FBFB237D8AB13FB  # 0.123813143156 135
+    .quad 0x03FBFB237D8AB13FB
+    .quad 0x03FBFF1A13EAC95FD  # 0.124780729104 136
+    .quad 0x03FBFF1A13EAC95FD
+    .quad 0x03FC014040CAB0229  # 0.125610834299 137
+    .quad 0x03FC014040CAB0229
+    .quad 0x03FC02F3D4301417B  # 0.126441629140 138
+    .quad 0x03FC02F3D4301417B
+    .quad 0x03FC04A7C44CF87A4  # 0.127273114776 139
+    .quad 0x03FC04A7C44CF87A4
+    .quad 0x03FC06A4D1D26C5E9  # 0.128244055971 140
+    .quad 0x03FC06A4D1D26C5E9
+    .quad 0x03FC08598B59E3A07  # 0.129077042275 141
+    .quad 0x03FC08598B59E3A07
+    .quad 0x03FC0A0EA2164AF02  # 0.129910723024 142
+    .quad 0x03FC0A0EA2164AF02
+    .quad 0x03FC0BC4162F73B66  # 0.130745099376 143
+    .quad 0x03FC0BC4162F73B66
+    .quad 0x03FC0D79E7CD48E58  # 0.131580172493 144
+    .quad 0x03FC0D79E7CD48E58
+    .quad 0x03FC0F301717CF0FB  # 0.132415943541 145
+    .quad 0x03FC0F301717CF0FB
+    .quad 0x03FC10E6A437247B7  # 0.133252413686 146
+    .quad 0x03FC10E6A437247B7
+    .quad 0x03FC12E6BFA8FEAD6  # 0.134229180665 147
+    .quad 0x03FC12E6BFA8FEAD6
+    .quad 0x03FC149E189F8642E  # 0.135067169541 148
+    .quad 0x03FC149E189F8642E
+    .quad 0x03FC1655CFEA923A4  # 0.135905861231 149
+    .quad 0x03FC1655CFEA923A4
+    .quad 0x03FC180DE5B2ACE5C  # 0.136745256915 150
+    .quad 0x03FC180DE5B2ACE5C
+    .quad 0x03FC19C65A207AC07  # 0.137585357777 151
+    .quad 0x03FC19C65A207AC07
+    .quad 0x03FC1B7F2D5CBA842  # 0.138426165001 152
+    .quad 0x03FC1B7F2D5CBA842
+    .quad 0x03FC1D385F90453F2  # 0.139267679777 153
+    .quad 0x03FC1D385F90453F2
+    .quad 0x03FC1EF1F0E40E6CD  # 0.140109903297 154
+    .quad 0x03FC1EF1F0E40E6CD
+    .quad 0x03FC20ABE18124098  # 0.140952836755 155
+    .quad 0x03FC20ABE18124098
+    .quad 0x03FC22663190AEACC  # 0.141796481350 156
+    .quad 0x03FC22663190AEACC
+    .quad 0x03FC2420E13BF19E3  # 0.142640838281 157
+    .quad 0x03FC2420E13BF19E3
+    .quad 0x03FC25DBF0AC4AED2  # 0.143485908754 158
+    .quad 0x03FC25DBF0AC4AED2
+    .quad 0x03FC2797600B3387B  # 0.144331693975 159
+    .quad 0x03FC2797600B3387B
+    .quad 0x03FC29532F823F525  # 0.145178195155 160
+    .quad 0x03FC29532F823F525
+    .quad 0x03FC2B0F5F3B1D3EF  # 0.146025413505 161
+    .quad 0x03FC2B0F5F3B1D3EF
+    .quad 0x03FC2CCBEF5F97653  # 0.146873350243 162
+    .quad 0x03FC2CCBEF5F97653
+    .quad 0x03FC2E88E01993187  # 0.147722006588 163
+    .quad 0x03FC2E88E01993187
+    .quad 0x03FC3046319311009  # 0.148571383763 164
+    .quad 0x03FC3046319311009
+    .quad 0x03FC3203E3F62D328  # 0.149421482992 165
+    .quad 0x03FC3203E3F62D328
+    .quad 0x03FC33C1F76D1F469  # 0.150272305505 166
+    .quad 0x03FC33C1F76D1F469
+    .quad 0x03FC35806C223A70F  # 0.151123852534 167
+    .quad 0x03FC35806C223A70F
+    .quad 0x03FC373F423FED9A1  # 0.151976125313 168
+    .quad 0x03FC373F423FED9A1
+    .quad 0x03FC38FE79F0C3771  # 0.152829125080 169
+    .quad 0x03FC38FE79F0C3771
+    .quad 0x03FC3ABE135F62A12  # 0.153682853077 170
+    .quad 0x03FC3ABE135F62A12
+    .quad 0x03FC3C335E0447D71  # 0.154394850259 171
+    .quad 0x03FC3C335E0447D71
+    .quad 0x03FC3DF3AB13505F9  # 0.155249916579 172
+    .quad 0x03FC3DF3AB13505F9
+    .quad 0x03FC3FB45A59928CA  # 0.156105714663 173
+    .quad 0x03FC3FB45A59928CA
+    .quad 0x03FC41756C0220C81  # 0.156962245765 174
+    .quad 0x03FC41756C0220C81
+    .quad 0x03FC4336E03829D61  # 0.157819511141 175
+    .quad 0x03FC4336E03829D61
+    .quad 0x03FC44F8B726F8EFE  # 0.158677512051 176
+    .quad 0x03FC44F8B726F8EFE
+    .quad 0x03FC46BAF0F9F5DB8  # 0.159536249760 177
+    .quad 0x03FC46BAF0F9F5DB8
+    .quad 0x03FC48326CD3EC797  # 0.160252428262 178
+    .quad 0x03FC48326CD3EC797
+    .quad 0x03FC49F55C6502F81  # 0.161112520058 179
+    .quad 0x03FC49F55C6502F81
+    .quad 0x03FC4BB8AF55DE908  # 0.161973352249 180
+    .quad 0x03FC4BB8AF55DE908
+    .quad 0x03FC4D7C65D25566D  # 0.162834926111 181
+    .quad 0x03FC4D7C65D25566D
+    .quad 0x03FC4F4080065AA7F  # 0.163697242922 182
+    .quad 0x03FC4F4080065AA7F
+    .quad 0x03FC50B98CD30A759  # 0.164416408720 183
+    .quad 0x03FC50B98CD30A759
+    .quad 0x03FC527E5E4A1B58D  # 0.165280090939 184
+    .quad 0x03FC527E5E4A1B58D
+    .quad 0x03FC544393F5DF80F  # 0.166144519750 185
+    .quad 0x03FC544393F5DF80F
+    .quad 0x03FC56092E02BA514  # 0.167009696444 186
+    .quad 0x03FC56092E02BA514
+    .quad 0x03FC57837B3098F2C  # 0.167731249257 187
+    .quad 0x03FC57837B3098F2C
+    .quad 0x03FC5949CDB873419  # 0.168597800437 188
+    .quad 0x03FC5949CDB873419
+    .quad 0x03FC5B10851FC924A  # 0.169465103180 189
+    .quad 0x03FC5B10851FC924A
+    .quad 0x03FC5C8BC079D8289  # 0.170188430518 190
+    .quad 0x03FC5C8BC079D8289
+    .quad 0x03FC5E533144C1718  # 0.171057114516 191
+    .quad 0x03FC5E533144C1718
+    .quad 0x03FC601B076E7A8A8  # 0.171926553783 192
+    .quad 0x03FC601B076E7A8A8
+    .quad 0x03FC619732215D786  # 0.172651664394 193
+    .quad 0x03FC619732215D786
+    .quad 0x03FC635FC298F6C77  # 0.173522491735 194
+    .quad 0x03FC635FC298F6C77
+    .quad 0x03FC6528B8EFA5D16  # 0.174394078077 195
+    .quad 0x03FC6528B8EFA5D16
+    .quad 0x03FC66A5D42A3AD33  # 0.175120980777 196
+    .quad 0x03FC66A5D42A3AD33
+    .quad 0x03FC686F85BAD4298  # 0.175993962063 197
+    .quad 0x03FC686F85BAD4298
+    .quad 0x03FC6A399DABBD383  # 0.176867706111 198
+    .quad 0x03FC6A399DABBD383
+    .quad 0x03FC6BB7AA9F22C40  # 0.177596409780 199
+    .quad 0x03FC6BB7AA9F22C40
+    .quad 0x03FC6D827EB7C1E57  # 0.178471555693 200
+    .quad 0x03FC6D827EB7C1E57
+    .quad 0x03FC6F0128B756AB9  # 0.179201429458 201
+    .quad 0x03FC6F0128B756AB9
+    .quad 0x03FC70CCB9927BCF6  # 0.180077981742 202
+    .quad 0x03FC70CCB9927BCF6
+    .quad 0x03FC7298B1A4E32B6  # 0.180955303044 203
+    .quad 0x03FC7298B1A4E32B6
+    .quad 0x03FC74184F58CC7DC  # 0.181686992547 204
+    .quad 0x03FC74184F58CC7DC
+    .quad 0x03FC75E5051E74141  # 0.182565727226 205
+    .quad 0x03FC75E5051E74141
+    .quad 0x03FC77654128F6127  # 0.183298596442 206
+    .quad 0x03FC77654128F6127
+    .quad 0x03FC7932B53E97639  # 0.184178749058 207
+    .quad 0x03FC7932B53E97639
+    .quad 0x03FC7AB390229D8FD  # 0.184912801796 208
+    .quad 0x03FC7AB390229D8FD
+    .quad 0x03FC7C81C325B4A5E  # 0.185794376934 209
+    .quad 0x03FC7C81C325B4A5E
+    .quad 0x03FC7E033D66CD24A  # 0.186529617023 210
+    .quad 0x03FC7E033D66CD24A
+    .quad 0x03FC7FD22FF599D4C  # 0.187412619288 211
+    .quad 0x03FC7FD22FF599D4C
+    .quad 0x03FC81544A17F67C1  # 0.188149050576 212
+    .quad 0x03FC81544A17F67C1
+    .quad 0x03FC8323FCD17DAC8  # 0.189033484595 213
+    .quad 0x03FC8323FCD17DAC8
+    .quad 0x03FC84A6B759F512D  # 0.189771110947 214
+    .quad 0x03FC84A6B759F512D
+    .quad 0x03FC86772ADE0201C  # 0.190656981373 215
+    .quad 0x03FC86772ADE0201C
+    .quad 0x03FC87FA865210911  # 0.191395806674 216
+    .quad 0x03FC87FA865210911
+    .quad 0x03FC89CBBB4136201  # 0.192283118179 217
+    .quad 0x03FC89CBBB4136201
+    .quad 0x03FC8B4FB826FF291  # 0.193023146334 218
+    .quad 0x03FC8B4FB826FF291
+    .quad 0x03FC8D21AF2299298  # 0.193911903613 219
+    .quad 0x03FC8D21AF2299298
+    .quad 0x03FC8EA64E00E7FC0  # 0.194653138545 220
+    .quad 0x03FC8EA64E00E7FC0
+    .quad 0x03FC902B36AB7681D  # 0.195394923313 221
+    .quad 0x03FC902B36AB7681D
+    .quad 0x03FC91FE49096581E  # 0.196285791969 222
+    .quad 0x03FC91FE49096581E
+    .quad 0x03FC9383D471B869B  # 0.197028789254 223
+    .quad 0x03FC9383D471B869B
+    .quad 0x03FC9557AA6B87F65  # 0.197921115309 224
+    .quad 0x03FC9557AA6B87F65
+    .quad 0x03FC96DDD91A0B959  # 0.198665329082 225
+    .quad 0x03FC96DDD91A0B959
+    .quad 0x03FC9864522D04491  # 0.199410097121 226
+    .quad 0x03FC9864522D04491
+    .quad 0x03FC9A3945D1A44B3  # 0.200304551564 227
+    .quad 0x03FC9A3945D1A44B3
+    .quad 0x03FC9BC062F26FC3B  # 0.201050541900 228
+    .quad 0x03FC9BC062F26FC3B
+    .quad 0x03FC9D47CAD2C1871  # 0.201797089154 229
+    .quad 0x03FC9D47CAD2C1871
+    .quad 0x03FC9F1DDD7FE4F8B  # 0.202693682161 230
+    .quad 0x03FC9F1DDD7FE4F8B
+    .quad 0x03FCA0A5EA371A910  # 0.203441457564 231
+    .quad 0x03FCA0A5EA371A910
+    .quad 0x03FCA22E42098F498  # 0.204189792554 232
+    .quad 0x03FCA22E42098F498
+    .quad 0x03FCA405751F6CCE4  # 0.205088534376 233
+    .quad 0x03FCA405751F6CCE4
+    .quad 0x03FCA58E729348F40  # 0.205838103409 234
+    .quad 0x03FCA58E729348F40
+    .quad 0x03FCA717BB7EC64A3  # 0.206588234717 235
+    .quad 0x03FCA717BB7EC64A3
+    .quad 0x03FCA8F010601E5FD  # 0.207489135679 236
+    .quad 0x03FCA8F010601E5FD
+    .quad 0x03FCAA79FFB8FCD48  # 0.208240506966 237
+    .quad 0x03FCAA79FFB8FCD48
+    .quad 0x03FCAC043AE68965A  # 0.208992443238 238
+    .quad 0x03FCAC043AE68965A
+    .quad 0x03FCAD8EC205FB6AD  # 0.209744945343 239
+    .quad 0x03FCAD8EC205FB6AD
+    .quad 0x03FCAF6895610DBAD  # 0.210648695969 240
+    .quad 0x03FCAF6895610DBAD
+    .quad 0x03FCB0F3C3FBD65C9  # 0.211402445910 241
+    .quad 0x03FCB0F3C3FBD65C9
+    .quad 0x03FCB27F3EE674219  # 0.212156764419 242
+    .quad 0x03FCB27F3EE674219
+    .quad 0x03FCB40B063E65B0F  # 0.212911652354 243
+    .quad 0x03FCB40B063E65B0F
+    .quad 0x03FCB5E65A8096C88  # 0.213818270730 244
+    .quad 0x03FCB5E65A8096C88
+    .quad 0x03FCB772CA646760C  # 0.214574414434 245
+    .quad 0x03FCB772CA646760C
+    .quad 0x03FCB8FF871461198  # 0.215331130323 246
+    .quad 0x03FCB8FF871461198
+    .quad 0x03FCBA8C90AE4AD19  # 0.216088419265 247
+    .quad 0x03FCBA8C90AE4AD19
+    .quad 0x03FCBC19E74FFCBDA  # 0.216846282128 248
+    .quad 0x03FCBC19E74FFCBDA
+    .quad 0x03FCBDF71B83DAE7A  # 0.217756476365 249
+    .quad 0x03FCBDF71B83DAE7A
+    .quad 0x03FCBF851C067555C  # 0.218515604922 250
+    .quad 0x03FCBF851C067555C
+    .quad 0x03FCC11369F0CDB3C  # 0.219275310193 251
+    .quad 0x03FCC11369F0CDB3C
+    .quad 0x03FCC2A205610593E  # 0.220035593055 252
+    .quad 0x03FCC2A205610593E
+    .quad 0x03FCC430EE755023B  # 0.220796454387 253
+    .quad 0x03FCC430EE755023B
+    .quad 0x03FCC5C0254BF23A8  # 0.221557895069 254
+    .quad 0x03FCC5C0254BF23A8
+    .quad 0x03FCC79F9AB632BF1  # 0.222472389875 255
+    .quad 0x03FCC79F9AB632BF1
+    .quad 0x03FCC92F7D09ABE20  # 0.223235108240 256
+    .quad 0x03FCC92F7D09ABE20
+    .quad 0x03FCCABFAD80D023D  # 0.223998408788 257
+    .quad 0x03FCCABFAD80D023D
+    .quad 0x03FCCC502C3A2F1E8  # 0.224762292410 258
+    .quad 0x03FCCC502C3A2F1E8
+    .quad 0x03FCCDE0F9546A5E7  # 0.225526759995 259
+    .quad 0x03FCCDE0F9546A5E7
+    .quad 0x03FCCF7214EE356E9  # 0.226291812439 260
+    .quad 0x03FCCF7214EE356E9
+    .quad 0x03FCD1037F2655E7B  # 0.227057450635 261
+    .quad 0x03FCD1037F2655E7B
+    .quad 0x03FCD295381BA37E9  # 0.227823675483 262
+    .quad 0x03FCD295381BA37E9
+    .quad 0x03FCD4273FED08111  # 0.228590487882 263
+    .quad 0x03FCD4273FED08111
+    .quad 0x03FCD5B996B97FB5F  # 0.229357888733 264
+    .quad 0x03FCD5B996B97FB5F
+    .quad 0x03FCD74C3CA018C9C  # 0.230125878940 265
+    .quad 0x03FCD74C3CA018C9C
+    .quad 0x03FCD8DF31BFF3FF2  # 0.230894459410 266
+    .quad 0x03FCD8DF31BFF3FF2
+    .quad 0x03FCDA727638446A1  # 0.231663631050 267
+    .quad 0x03FCDA727638446A1
+    .quad 0x03FCDC56CAE452F5B  # 0.232587418645 268
+    .quad 0x03FCDC56CAE452F5B
+    .quad 0x03FCDDEABE5A3926E  # 0.233357894066 269
+    .quad 0x03FCDDEABE5A3926E
+    .quad 0x03FCDF7F018CE771F  # 0.234128963578 270
+    .quad 0x03FCDF7F018CE771F
+    .quad 0x03FCE113949BDEC62  # 0.234900628096 271
+    .quad 0x03FCE113949BDEC62
+    .quad 0x03FCE2A877A6B2C0F  # 0.235672888541 272
+    .quad 0x03FCE2A877A6B2C0F
+    .quad 0x03FCE43DAACD09BEC  # 0.236445745833 273
+    .quad 0x03FCE43DAACD09BEC
+    .quad 0x03FCE5D32E2E9CE87  # 0.237219200895 274
+    .quad 0x03FCE5D32E2E9CE87
+    .quad 0x03FCE76901EB38427  # 0.237993254653 275
+    .quad 0x03FCE76901EB38427
+    .quad 0x03FCE8ADE53F76866  # 0.238612929343 276
+    .quad 0x03FCE8ADE53F76866
+    .quad 0x03FCEA4449F04AAF4  # 0.239388063093 277
+    .quad 0x03FCEA4449F04AAF4
+    .quad 0x03FCEBDAFF5593E99  # 0.240163798141 278
+    .quad 0x03FCEBDAFF5593E99
+    .quad 0x03FCED72058F666C5  # 0.240940135421 279
+    .quad 0x03FCED72058F666C5
+    .quad 0x03FCEF095CBDE9937  # 0.241717075868 280
+    .quad 0x03FCEF095CBDE9937
+    .quad 0x03FCF0A1050157ED6  # 0.242494620422 281
+    .quad 0x03FCF0A1050157ED6
+    .quad 0x03FCF238FE79FF4BF  # 0.243272770021 282
+    .quad 0x03FCF238FE79FF4BF
+    .quad 0x03FCF3D1494840D2F  # 0.244051525609 283
+    .quad 0x03FCF3D1494840D2F
+    .quad 0x03FCF569E58C91077  # 0.244830888130 284
+    .quad 0x03FCF569E58C91077
+    .quad 0x03FCF702D36777DF0  # 0.245610858531 285
+    .quad 0x03FCF702D36777DF0
+    .quad 0x03FCF89C12F990D0C  # 0.246391437760 286
+    .quad 0x03FCF89C12F990D0C
+    .quad 0x03FCFA35A4638AE2C  # 0.247172626770 287
+    .quad 0x03FCFA35A4638AE2C
+    .quad 0x03FCFB7D86EEE3B92  # 0.247798017660 288
+    .quad 0x03FCFB7D86EEE3B92
+    .quad 0x03FCFD17ABFCDB683  # 0.248580306677 289
+    .quad 0x03FCFD17ABFCDB683
+    .quad 0x03FCFEB2233EA07CB  # 0.249363208150 290
+    .quad 0x03FCFEB2233EA07CB
+    .quad 0x03FD0026766A9671C  # 0.250146723037 291
+    .quad 0x03FD0026766A9671C
+    .quad 0x03FD00F40470C7323  # 0.250930852302 292
+    .quad 0x03FD00F40470C7323
+    .quad 0x03FD01C1BBC2735A3  # 0.251715596908 293
+    .quad 0x03FD01C1BBC2735A3
+    .quad 0x03FD028F9C7035C1D  # 0.252500957822 294
+    .quad 0x03FD028F9C7035C1D
+    .quad 0x03FD03346E0106062  # 0.253129690945 295
+    .quad 0x03FD03346E0106062
+    .quad 0x03FD0402994B4F041  # 0.253916163656 296
+    .quad 0x03FD0402994B4F041
+    .quad 0x03FD04D0EE20620AF  # 0.254703255393 297
+    .quad 0x03FD04D0EE20620AF
+    .quad 0x03FD059F6C910034D  # 0.255490967131 298
+    .quad 0x03FD059F6C910034D
+    .quad 0x03FD066E14ADF4BFD  # 0.256279299848 299
+    .quad 0x03FD066E14ADF4BFD
+    .quad 0x03FD07138604D5864  # 0.256910413785 300
+    .quad 0x03FD07138604D5864
+    .quad 0x03FD07E2794F3E8C1  # 0.257699866735 301
+    .quad 0x03FD07E2794F3E8C1
+    .quad 0x03FD08B196753A125  # 0.258489943414 302
+    .quad 0x03FD08B196753A125
+    .quad 0x03FD0980DD87BA2DD  # 0.259280644807 303
+    .quad 0x03FD0980DD87BA2DD
+    .quad 0x03FD0A504E97BB40C  # 0.260071971904 304
+    .quad 0x03FD0A504E97BB40C
+    .quad 0x03FD0AF660EB9E278  # 0.260705484754 305
+    .quad 0x03FD0AF660EB9E278
+    .quad 0x03FD0BC61DBBA97CB  # 0.261497940616 306
+    .quad 0x03FD0BC61DBBA97CB
+    .quad 0x03FD0C9604B8FC51E  # 0.262291024962 307
+    .quad 0x03FD0C9604B8FC51E
+    .quad 0x03FD0D3C7586CD5E5  # 0.262925945618 308
+    .quad 0x03FD0D3C7586CD5E5
+    .quad 0x03FD0E0CA89A72D29  # 0.263720163752 309
+    .quad 0x03FD0E0CA89A72D29
+    .quad 0x03FD0EDD060B78082  # 0.264515013170 310
+    .quad 0x03FD0EDD060B78082
+    .quad 0x03FD0FAD8DEB1E2C0  # 0.265310494876 311
+    .quad 0x03FD0FAD8DEB1E2C0
+    .quad 0x03FD10547F9D26ABC  # 0.265947336165 312
+    .quad 0x03FD10547F9D26ABC
+    .quad 0x03FD1125540925114  # 0.266743958529 313
+    .quad 0x03FD1125540925114
+    .quad 0x03FD11F653144CB8B  # 0.267541216005 314
+    .quad 0x03FD11F653144CB8B
+    .quad 0x03FD129DA43F5BE9E  # 0.268179479949 315
+    .quad 0x03FD129DA43F5BE9E
+    .quad 0x03FD136EF02E8290C  # 0.268977883185 316
+    .quad 0x03FD136EF02E8290C
+    .quad 0x03FD144066EDAE406  # 0.269776924378 317
+    .quad 0x03FD144066EDAE406
+    .quad 0x03FD14E817FF359D7  # 0.270416617347 318
+    .quad 0x03FD14E817FF359D7
+    .quad 0x03FD15B9DBFA9DEC8  # 0.271216809436 319
+    .quad 0x03FD15B9DBFA9DEC8
+    .quad 0x03FD168BCAF73B3EB  # 0.272017642345 320
+    .quad 0x03FD168BCAF73B3EB
+    .quad 0x03FD1733DC5D68DE8  # 0.272658770753 321
+    .quad 0x03FD1733DC5D68DE8
+    .quad 0x03FD180618EF18ADE  # 0.273460759729 322
+    .quad 0x03FD180618EF18ADE
+    .quad 0x03FD18D880B3826FE  # 0.274263392407 323
+    .quad 0x03FD18D880B3826FE
+    .quad 0x03FD1980F2DD42B6F  # 0.274905962710 324
+    .quad 0x03FD1980F2DD42B6F
+    .quad 0x03FD1A53A8902E70B  # 0.275709756661 325
+    .quad 0x03FD1A53A8902E70B
+    .quad 0x03FD1AFC59297024D  # 0.276353257326 326
+    .quad 0x03FD1AFC59297024D
+    .quad 0x03FD1BCF5D04AE1EA  # 0.277158215914 327
+    .quad 0x03FD1BCF5D04AE1EA
+    .quad 0x03FD1CA28C64BAE54  # 0.277963822983 328
+    .quad 0x03FD1CA28C64BAE54
+    .quad 0x03FD1D4B9E796C245  # 0.278608776246 329
+    .quad 0x03FD1D4B9E796C245
+    .quad 0x03FD1E1F1C5C3A06C  # 0.279415553216 330
+    .quad 0x03FD1E1F1C5C3A06C
+    .quad 0x03FD1EC86D5747AAD  # 0.280061443760 331
+    .quad 0x03FD1EC86D5747AAD
+    .quad 0x03FD1F9C39F74C559  # 0.280869394034 332
+    .quad 0x03FD1F9C39F74C559
+    .quad 0x03FD2070326F1F789  # 0.281677997620 333
+    .quad 0x03FD2070326F1F789
+    .quad 0x03FD2119E59F8789C  # 0.282325351583 334
+    .quad 0x03FD2119E59F8789C
+    .quad 0x03FD21EE2D300381C  # 0.283135133796 335
+    .quad 0x03FD21EE2D300381C
+    .quad 0x03FD22981FBEF797A  # 0.283783432036 336
+    .quad 0x03FD22981FBEF797A
+    .quad 0x03FD236CB6A339EED  # 0.284594396317 337
+    .quad 0x03FD236CB6A339EED
+    .quad 0x03FD2416E8C01F606  # 0.285243641592 338
+    .quad 0x03FD2416E8C01F606
+    .quad 0x03FD24EBCF3387FF6  # 0.286055791397 339
+    .quad 0x03FD24EBCF3387FF6
+    .quad 0x03FD2596410DF963A  # 0.286705986479 340
+    .quad 0x03FD2596410DF963A
+    .quad 0x03FD266B774C2AF55  # 0.287519325279 341
+    .quad 0x03FD266B774C2AF55
+    .quad 0x03FD27162913F873F  # 0.288170472950 342
+    .quad 0x03FD27162913F873F
+    .quad 0x03FD27EBAF58D8C9C  # 0.288985004232 343
+    .quad 0x03FD27EBAF58D8C9C
+    .quad 0x03FD2896A13E086A3  # 0.289637107288 344
+    .quad 0x03FD2896A13E086A3
+    .quad 0x03FD296C77C5C0E13  # 0.290452834554 345
+    .quad 0x03FD296C77C5C0E13
+    .quad 0x03FD2A17A9F88EDD2  # 0.291105895801 346
+    .quad 0x03FD2A17A9F88EDD2
+    .quad 0x03FD2AEDD0FF8CC2C  # 0.291922822568 347
+    .quad 0x03FD2AEDD0FF8CC2C
+    .quad 0x03FD2B9943B06BD77  # 0.292576844829 348
+    .quad 0x03FD2B9943B06BD77
+    .quad 0x03FD2C6FBB7360D0E  # 0.293394974630 349
+    .quad 0x03FD2C6FBB7360D0E
+    .quad 0x03FD2D1B6ED2FA90C  # 0.294049960734 350
+    .quad 0x03FD2D1B6ED2FA90C
+    .quad 0x03FD2DC73F01B0DD4  # 0.294705376127 351
+    .quad 0x03FD2DC73F01B0DD4
+    .quad 0x03FD2E9E2BCE12286  # 0.295525249913 352
+    .quad 0x03FD2E9E2BCE12286
+    .quad 0x03FD2F4A3CF22EDC2  # 0.296181633264 353
+    .quad 0x03FD2F4A3CF22EDC2
+    .quad 0x03FD30217B1006601  # 0.297002718785 354
+    .quad 0x03FD30217B1006601
+    .quad 0x03FD30CDCD5ABA762  # 0.297660072959 355
+    .quad 0x03FD30CDCD5ABA762
+    .quad 0x03FD31A55D07A8590  # 0.298482373803 356
+    .quad 0x03FD31A55D07A8590
+    .quad 0x03FD3251F0AA5CC1A  # 0.299140701674 357
+    .quad 0x03FD3251F0AA5CC1A
+    .quad 0x03FD32FEA167A6D70  # 0.299799463226 358
+    .quad 0x03FD32FEA167A6D70
+    .quad 0x03FD33D6A7509D491  # 0.300623525901 359
+    .quad 0x03FD33D6A7509D491
+    .quad 0x03FD348399ADA9D94  # 0.301283265328 360
+    .quad 0x03FD348399ADA9D94
+    .quad 0x03FD3530A9454ADC9  # 0.301943440298 361
+    .quad 0x03FD3530A9454ADC9
+    .quad 0x03FD360925EC44F5C  # 0.302769272371 362
+    .quad 0x03FD360925EC44F5C
+    .quad 0x03FD36B6776BE1116  # 0.303430429420 363
+    .quad 0x03FD36B6776BE1116
+    .quad 0x03FD378F469437FB4  # 0.304257490918 364
+    .quad 0x03FD378F469437FB4
+    .quad 0x03FD383CDA2E14ECB  # 0.304919632971 365
+    .quad 0x03FD383CDA2E14ECB
+    .quad 0x03FD38EA8B3924521  # 0.305582213748 366
+    .quad 0x03FD38EA8B3924521
+    .quad 0x03FD39C3D1FD60E74  # 0.306411057558 367
+    .quad 0x03FD39C3D1FD60E74
+    .quad 0x03FD3A71C56BB48C7  # 0.307074627589 368
+    .quad 0x03FD3A71C56BB48C7
+    .quad 0x03FD3B1FD66BC8D10  # 0.307738638238 369
+    .quad 0x03FD3B1FD66BC8D10
+    .quad 0x03FD3BF995502CB5C  # 0.308569272059 370
+    .quad 0x03FD3BF995502CB5C
+    .quad 0x03FD3CA7E8FD01DF6  # 0.309234276240 371
+    .quad 0x03FD3CA7E8FD01DF6
+    .quad 0x03FD3D565A5C5BF11  # 0.309899722945 372
+    .quad 0x03FD3D565A5C5BF11
+    .quad 0x03FD3E3091E6049FB  # 0.310732154526 373
+    .quad 0x03FD3E3091E6049FB
+    .quad 0x03FD3EDF463C1683E  # 0.311398599069 374
+    .quad 0x03FD3EDF463C1683E
+    .quad 0x03FD3F8E1865A82DD  # 0.312065488057 375
+    .quad 0x03FD3F8E1865A82DD
+    .quad 0x03FD403D086CEA79B  # 0.312732822082 376
+    .quad 0x03FD403D086CEA79B
+    .quad 0x03FD4117DE854CA15  # 0.313567616354 377
+    .quad 0x03FD4117DE854CA15
+    .quad 0x03FD41C711E4BA15E  # 0.314235953889 378
+    .quad 0x03FD41C711E4BA15E
+    .quad 0x03FD427663431B221  # 0.314904738398 379
+    .quad 0x03FD427663431B221
+    .quad 0x03FD4325D2AAB6F18  # 0.315573970480 380
+    .quad 0x03FD4325D2AAB6F18
+    .quad 0x03FD44014838E5513  # 0.316411140893 381
+    .quad 0x03FD44014838E5513
+    .quad 0x03FD44B0FB5AF4F44  # 0.317081382205 382
+    .quad 0x03FD44B0FB5AF4F44
+    .quad 0x03FD4560CCA7CB3B2  # 0.317752073041 383
+    .quad 0x03FD4560CCA7CB3B2
+    .quad 0x03FD4610BC29C5E18  # 0.318423214006 384
+    .quad 0x03FD4610BC29C5E18
+    .quad 0x03FD46ECD216CDCB5  # 0.319262774126 385
+    .quad 0x03FD46ECD216CDCB5
+    .quad 0x03FD479D05B65CB60  # 0.319934930091 386
+    .quad 0x03FD479D05B65CB60
+    .quad 0x03FD484D57ACE5A1A  # 0.320607538154 387
+    .quad 0x03FD484D57ACE5A1A
+    .quad 0x03FD48FDC804DD1CB  # 0.321280598924 388
+    .quad 0x03FD48FDC804DD1CB
+    .quad 0x03FD49DA7F3BCC420  # 0.322122562432 389
+    .quad 0x03FD49DA7F3BCC420
+    .quad 0x03FD4A8B341552B09  # 0.322796644021 390
+    .quad 0x03FD4A8B341552B09
+    .quad 0x03FD4B3C077267E9A  # 0.323471180303 391
+    .quad 0x03FD4B3C077267E9A
+    .quad 0x03FD4BECF95D97914  # 0.324146171892 392
+    .quad 0x03FD4BECF95D97914
+    .quad 0x03FD4C9E09E172C3D  # 0.324821619401 393
+    .quad 0x03FD4C9E09E172C3D
+    .quad 0x03FD4D4F3908901A0  # 0.325497523449 394
+    .quad 0x03FD4D4F3908901A0
+    .quad 0x03FD4E2CDF1F341C1  # 0.326343046455 395
+    .quad 0x03FD4E2CDF1F341C1
+    .quad 0x03FD4EDE535C79642  # 0.327019979972 396
+    .quad 0x03FD4EDE535C79642
+    .quad 0x03FD4F8FE65F90500  # 0.327697372039 397
+    .quad 0x03FD4F8FE65F90500
+    .quad 0x03FD5041983326F2D  # 0.328375223276 398
+    .quad 0x03FD5041983326F2D
+    .quad 0x03FD50F368E1F0F02  # 0.329053534308 399
+    .quad 0x03FD50F368E1F0F02
+    .quad 0x03FD51A55876A77F5  # 0.329732305758 400
+    .quad 0x03FD51A55876A77F5
+    .quad 0x03FD5283EF743F98B  # 0.330581418486 401
+    .quad 0x03FD5283EF743F98B
+    .quad 0x03FD533624B59CA35  # 0.331261228165 402
+    .quad 0x03FD533624B59CA35
+    .quad 0x03FD53E878FFE6EAE  # 0.331941500300 403
+    .quad 0x03FD53E878FFE6EAE
+    .quad 0x03FD549AEC5DEF880  # 0.332622235521 404
+    .quad 0x03FD549AEC5DEF880
+    .quad 0x03FD554D7EDA8D3C4  # 0.333303434457 405
+    .quad 0x03FD554D7EDA8D3C4
+    .quad 0x03FD560030809C759  # 0.333985097742 406
+    .quad 0x03FD560030809C759
+    .quad 0x03FD56B3015AFF52C  # 0.334667226008 407
+    .quad 0x03FD56B3015AFF52C
+    .quad 0x03FD5765F1749DA6C  # 0.335349819892 408
+    .quad 0x03FD5765F1749DA6C
+    .quad 0x03FD581900D864FD7  # 0.336032880027 409
+    .quad 0x03FD581900D864FD7
+    .quad 0x03FD58CC2F91489F5  # 0.336716407053 410
+    .quad 0x03FD58CC2F91489F5
+    .quad 0x03FD59AC5618CCE38  # 0.337571473373 411
+    .quad 0x03FD59AC5618CCE38
+    .quad 0x03FD5A5FCB795780C  # 0.338256053239 412
+    .quad 0x03FD5A5FCB795780C
+    .quad 0x03FD5B136052BCE39  # 0.338941102075 413
+    .quad 0x03FD5B136052BCE39
+    .quad 0x03FD5BC714B008E23  # 0.339626620526 414
+    .quad 0x03FD5BC714B008E23
+    .quad 0x03FD5C7AE89C4D254  # 0.340312609234 415
+    .quad 0x03FD5C7AE89C4D254
+    .quad 0x03FD5D2EDC22A12BA  # 0.340999068845 416
+    .quad 0x03FD5D2EDC22A12BA
+    .quad 0x03FD5DE2EF4E224D6  # 0.341686000008 417
+    .quad 0x03FD5DE2EF4E224D6
+    .quad 0x03FD5E972229F3C15  # 0.342373403369 418
+    .quad 0x03FD5E972229F3C15
+    .quad 0x03FD5F4B74C13EA04  # 0.343061279578 419
+    .quad 0x03FD5F4B74C13EA04
+    .quad 0x03FD5FFFE71F31E9A  # 0.343749629287 420
+    .quad 0x03FD5FFFE71F31E9A
+    .quad 0x03FD60B4794F02875  # 0.344438453147 421
+    .quad 0x03FD60B4794F02875
+    .quad 0x03FD61692B5BEB520  # 0.345127751813 422
+    .quad 0x03FD61692B5BEB520
+    .quad 0x03FD621DFD512D14F  # 0.345817525940 423
+    .quad 0x03FD621DFD512D14F
+    .quad 0x03FD62D2EF3A0E933  # 0.346507776183 424
+    .quad 0x03FD62D2EF3A0E933
+    .quad 0x03FD63880121DC8AB  # 0.347198503200 425
+    .quad 0x03FD63880121DC8AB
+    .quad 0x03FD643D3313E9B92  # 0.347889707652 426
+    .quad 0x03FD643D3313E9B92
+    .quad 0x03FD64F2851B8EE01  # 0.348581390197 427
+    .quad 0x03FD64F2851B8EE01
+    .quad 0x03FD65A7F7442AC90  # 0.349273551498 428
+    .quad 0x03FD65A7F7442AC90
+    .quad 0x03FD665D8999224A5  # 0.349966192218 429
+    .quad 0x03FD665D8999224A5
+    .quad 0x03FD67133C25E04A5  # 0.350659313022 430
+    .quad 0x03FD67133C25E04A5
+    .quad 0x03FD67C90EF5D5C4C  # 0.351352914576 431
+    .quad 0x03FD67C90EF5D5C4C
+    .quad 0x03FD687F021479CEE  # 0.352046997547 432
+    .quad 0x03FD687F021479CEE
+    .quad 0x03FD6935158D499B3  # 0.352741562603 433
+    .quad 0x03FD6935158D499B3
+    .quad 0x03FD69EB496BC87E5  # 0.353436610416 434
+    .quad 0x03FD69EB496BC87E5
+    .quad 0x03FD6AA19DBB7FF34  # 0.354132141656 435
+    .quad 0x03FD6AA19DBB7FF34
+    .quad 0x03FD6B581287FF9FD  # 0.354828156996 436
+    .quad 0x03FD6B581287FF9FD
+    .quad 0x03FD6C0EA7DCDD591  # 0.355524657112 437
+    .quad 0x03FD6C0EA7DCDD591
+    .quad 0x03FD6C97AD3CFCFD9  # 0.356047350738 438
+    .quad 0x03FD6C97AD3CFCFD9
+    .quad 0x03FD6D4E7B9C727EC  # 0.356744700836 439
+    .quad 0x03FD6D4E7B9C727EC
+    .quad 0x03FD6E056AA4421D6  # 0.357442537571 440
+    .quad 0x03FD6E056AA4421D6
+    .quad 0x03FD6EBC7A6019066  # 0.358140861621 441
+    .quad 0x03FD6EBC7A6019066
+    .quad 0x03FD6F73AADBAAAB7  # 0.358839673669 442
+    .quad 0x03FD6F73AADBAAAB7
+    .quad 0x03FD702AFC22B0C6D  # 0.359538974397 443
+    .quad 0x03FD702AFC22B0C6D
+    .quad 0x03FD70E26E40EB5FA  # 0.360238764489 444
+    .quad 0x03FD70E26E40EB5FA
+    .quad 0x03FD719A014220CF5  # 0.360939044629 445
+    .quad 0x03FD719A014220CF5
+    .quad 0x03FD7251B5321DC54  # 0.361639815506 446
+    .quad 0x03FD7251B5321DC54
+    .quad 0x03FD73098A1CB54BA  # 0.362341077807 447
+    .quad 0x03FD73098A1CB54BA
+    .quad 0x03FD73937F783CEBA  # 0.362867347444 448
+    .quad 0x03FD73937F783CEBA
+    .quad 0x03FD744B8E35E9EDA  # 0.363569471398 449
+    .quad 0x03FD744B8E35E9EDA
+    .quad 0x03FD7503BE0ED6C66  # 0.364272088676 450
+    .quad 0x03FD7503BE0ED6C66
+    .quad 0x03FD75BC0F0EEE7DE  # 0.364975199972 451
+    .quad 0x03FD75BC0F0EEE7DE
+    .quad 0x03FD76748142228C7  # 0.365678805982 452
+    .quad 0x03FD76748142228C7
+    .quad 0x03FD772D14B46AE00  # 0.366382907402 453
+    .quad 0x03FD772D14B46AE00
+    .quad 0x03FD77E5C971C5E06  # 0.367087504930 454
+    .quad 0x03FD77E5C971C5E06
+    .quad 0x03FD787066E04915F  # 0.367616279067 455
+    .quad 0x03FD787066E04915F
+    .quad 0x03FD792955FDF47A3  # 0.368321746469 456
+    .quad 0x03FD792955FDF47A3
+    .quad 0x03FD79E26687CFB3D  # 0.369027711906 457
+    .quad 0x03FD79E26687CFB3D
+    .quad 0x03FD7A9B9889F19E2  # 0.369734176082 458
+    .quad 0x03FD7A9B9889F19E2
+    .quad 0x03FD7B54EC1077A48  # 0.370441139703 459
+    .quad 0x03FD7B54EC1077A48
+    .quad 0x03FD7C0E612785C74  # 0.371148603475 460
+    .quad 0x03FD7C0E612785C74
+    .quad 0x03FD7C998F06FB152  # 0.371679529954 461
+    .quad 0x03FD7C998F06FB152
+    .quad 0x03FD7D533EF841E8A  # 0.372387870696 462
+    .quad 0x03FD7D533EF841E8A
+    .quad 0x03FD7E0D109B95F19  # 0.373096713539 463
+    .quad 0x03FD7E0D109B95F19
+    .quad 0x03FD7EC703FD340AA  # 0.373806059198 464
+    .quad 0x03FD7EC703FD340AA
+    .quad 0x03FD7F8119295FB9B  # 0.374515908385 465
+    .quad 0x03FD7F8119295FB9B
+    .quad 0x03FD800CBF3ED1CC2  # 0.375048626146 466
+    .quad 0x03FD800CBF3ED1CC2
+    .quad 0x03FD80C70FAB0BDF6  # 0.375759358229 467
+    .quad 0x03FD80C70FAB0BDF6
+    .quad 0x03FD81818203AFC7F  # 0.376470595813 468
+    .quad 0x03FD81818203AFC7F
+    .quad 0x03FD823C16551A3C3  # 0.377182339615 469
+    .quad 0x03FD823C16551A3C3
+    .quad 0x03FD82C81BE4DFF4A  # 0.377716480107 470
+    .quad 0x03FD82C81BE4DFF4A
+    .quad 0x03FD8382EBC7794D1  # 0.378429111528 471
+    .quad 0x03FD8382EBC7794D1
+    .quad 0x03FD843DDDC4FB137  # 0.379142251156 472
+    .quad 0x03FD843DDDC4FB137
+    .quad 0x03FD84F8F1E9DB72B  # 0.379855899714 473
+    .quad 0x03FD84F8F1E9DB72B
+    .quad 0x03FD85855776DCBFB  # 0.380391470556 474
+    .quad 0x03FD85855776DCBFB
+    .quad 0x03FD8640A77EB3957  # 0.381106011494 475
+    .quad 0x03FD8640A77EB3957
+    .quad 0x03FD86FC19D05148E  # 0.381821063366 476
+    .quad 0x03FD86FC19D05148E
+    .quad 0x03FD87B7AE7845C0F  # 0.382536626902 477
+    .quad 0x03FD87B7AE7845C0F
+    .quad 0x03FD8844748678822  # 0.383073635776 478
+    .quad 0x03FD8844748678822
+    .quad 0x03FD89004563D3DFD  # 0.383790096491 479
+    .quad 0x03FD89004563D3DFD
+    .quad 0x03FD89BC38BA356B4  # 0.384507070890 480
+    .quad 0x03FD89BC38BA356B4
+    .quad 0x03FD8A4945E20894E  # 0.385045139237 481
+    .quad 0x03FD8A4945E20894E
+    .quad 0x03FD8B0575AAB1FC5  # 0.385763014358 482
+    .quad 0x03FD8B0575AAB1FC5
+    .quad 0x03FD8BC1C80F45A32  # 0.386481405193 483
+    .quad 0x03FD8BC1C80F45A32
+    .quad 0x03FD8C7E3D1C80B2F  # 0.387200312485 484
+    .quad 0x03FD8C7E3D1C80B2F
+    .quad 0x03FD8D0BABACC89EE  # 0.387739832326 485
+    .quad 0x03FD8D0BABACC89EE
+    .quad 0x03FD8DC85D7FE5013  # 0.388459645206 486
+    .quad 0x03FD8DC85D7FE5013
+    .quad 0x03FD8E85321ED5598  # 0.389179976589 487
+    .quad 0x03FD8E85321ED5598
+    .quad 0x03FD8F12E873862C7  # 0.389720565845 488
+    .quad 0x03FD8F12E873862C7
+    .quad 0x03FD8FCFFA1614AA0  # 0.390441806410 489
+    .quad 0x03FD8FCFFA1614AA0
+    .quad 0x03FD908D2EA7D9511  # 0.391163567538 490
+    .quad 0x03FD908D2EA7D9511
+    .quad 0x03FD911B2D09ED9D6  # 0.391705230456 491
+    .quad 0x03FD911B2D09ED9D6
+    .quad 0x03FD91D89EDD6B7FF  # 0.392427904381 492
+    .quad 0x03FD91D89EDD6B7FF
+    .quad 0x03FD929633C3B7D3E  # 0.393151100941 493
+    .quad 0x03FD929633C3B7D3E
+    .quad 0x03FD93247A7C99B52  # 0.393693841796 494
+    .quad 0x03FD93247A7C99B52
+    .quad 0x03FD93E24CE3195E8  # 0.394417954789 495
+    .quad 0x03FD93E24CE3195E8
+    .quad 0x03FD9470C1CB1962E  # 0.394961383840 496
+    .quad 0x03FD9470C1CB1962E
+    .quad 0x03FD952ED1D9C0435  # 0.395686415592 497
+    .quad 0x03FD952ED1D9C0435
+    .quad 0x03FD95ED0535EA5D9  # 0.396411973396 498
+    .quad 0x03FD95ED0535EA5D9
+    .quad 0x03FD967BC2EDCCE17  # 0.396956487431 499
+    .quad 0x03FD967BC2EDCCE17
+    .quad 0x03FD973A3431356AE  # 0.397682967666 500
+    .quad 0x03FD973A3431356AE
+    .quad 0x03FD97F8C8E64A1C7  # 0.398409976059 501
+    .quad 0x03FD97F8C8E64A1C7
+    .quad 0x03FD9887CFB8A3932  # 0.398955579419 502
+    .quad 0x03FD9887CFB8A3932
+    .quad 0x03FD9946A2946EF3C  # 0.399683513937 503
+    .quad 0x03FD9946A2946EF3C
+    .quad 0x03FD99D5D8130607C  # 0.400229812776 504
+    .quad 0x03FD99D5D8130607C
+    .quad 0x03FD9A94E93E1EC37  # 0.400958675782 505
+    .quad 0x03FD9A94E93E1EC37
+    .quad 0x03FD9B244D87735E8  # 0.401505671875 506
+    .quad 0x03FD9B244D87735E8
+    .quad 0x03FD9BE39D2A97F0B  # 0.402235465741 507
+    .quad 0x03FD9BE39D2A97F0B
+    .quad 0x03FD9CA3109266E23  # 0.402965792595 508
+    .quad 0x03FD9CA3109266E23
+    .quad 0x03FD9D32BEA15ED3A  # 0.403513887977 509
+    .quad 0x03FD9D32BEA15ED3A
+    .quad 0x03FD9DF270C1914A8  # 0.404245149435 510
+    .quad 0x03FD9DF270C1914A8
+    .quad 0x03FD9E824DEA3E135  # 0.404793946669 511
+    .quad 0x03FD9E824DEA3E135
+    .quad 0x03FD9F423EEBF9DA1  # 0.405526145127 512
+    .quad 0x03FD9F423EEBF9DA1
+    .quad 0x03FD9FD24B4D47012  # 0.406075646011 513
+    .quad 0x03FD9FD24B4D47012
+    .quad 0x03FDA0927B59DA6E2  # 0.406808783874 514
+    .quad 0x03FDA0927B59DA6E2
+    .quad 0x03FDA152CF7F3B46D  # 0.407542459622 515
+    .quad 0x03FDA152CF7F3B46D
+    .quad 0x03FDA1E32653B420E  # 0.408093069896 516
+    .quad 0x03FDA1E32653B420E
+    .quad 0x03FDA2A3B9C527DB1  # 0.408827688845 517
+    .quad 0x03FDA2A3B9C527DB1
+    .quad 0x03FDA33440224FA79  # 0.409379007429 518
+    .quad 0x03FDA33440224FA79
+    .quad 0x03FDA3F513098DD09  # 0.410114572008 519
+    .quad 0x03FDA3F513098DD09
+    .quad 0x03FDA485C90EBDB0C  # 0.410666600728 520
+    .quad 0x03FDA485C90EBDB0C
+    .quad 0x03FDA546DB95A721A  # 0.411403113374 521
+    .quad 0x03FDA546DB95A721A
+    .quad 0x03FDA5D7C16257437  # 0.411955854060 522
+    .quad 0x03FDA5D7C16257437
+    .quad 0x03FDA69913B2F6572  # 0.412693317221 523
+    .quad 0x03FDA69913B2F6572
+    .quad 0x03FDA72A2966BE1EA  # 0.413246771713 524
+    .quad 0x03FDA72A2966BE1EA
+    .quad 0x03FDA7EBBBAB46E8B  # 0.413985187844 525
+    .quad 0x03FDA7EBBBAB46E8B
+    .quad 0x03FDA87D0165DD199  # 0.414539357989 526
+    .quad 0x03FDA87D0165DD199
+    .quad 0x03FDA93ED3C8AD9E3  # 0.415278729556 527
+    .quad 0x03FDA93ED3C8AD9E3
+    .quad 0x03FDA9D049A9E884A  # 0.415833617206 528
+    .quad 0x03FDA9D049A9E884A
+    .quad 0x03FDAA925C5588EFA  # 0.416573946686 529
+    .quad 0x03FDAA925C5588EFA
+    .quad 0x03FDAB24027D5E8AF  # 0.417129553701 530
+    .quad 0x03FDAB24027D5E8AF
+    .quad 0x03FDABE6559C8167C  # 0.417870843580 531
+    .quad 0x03FDABE6559C8167C
+    .quad 0x03FDAC782C2B07944  # 0.418427171828 532
+    .quad 0x03FDAC782C2B07944
+    .quad 0x03FDAD3ABFE88A06E  # 0.419169424599 533
+    .quad 0x03FDAD3ABFE88A06E
+    .quad 0x03FDADCCC6FDF6A80  # 0.419726475955 534
+    .quad 0x03FDADCCC6FDF6A80
+    .quad 0x03FDAE5EE2E961227  # 0.420283837790 535
+    .quad 0x03FDAE5EE2E961227
+    .quad 0x03FDAF21D34189D0A  # 0.421027470470 536
+    .quad 0x03FDAF21D34189D0A
+    .quad 0x03FDAFB41FE2167B4  # 0.421585558104 537
+    .quad 0x03FDAFB41FE2167B4
+    .quad 0x03FDB07751416A7F3  # 0.422330159776 538
+    .quad 0x03FDB07751416A7F3
+    .quad 0x03FDB109CEB79DB8A  # 0.422888975102 539
+    .quad 0x03FDB109CEB79DB8A
+    .quad 0x03FDB1CD41498DF12  # 0.423634548296 540
+    .quad 0x03FDB1CD41498DF12
+    .quad 0x03FDB25FEFB60CB2E  # 0.424194093214 541
+    .quad 0x03FDB25FEFB60CB2E
+    .quad 0x03FDB323A3A63594A  # 0.424940640468 542
+    .quad 0x03FDB323A3A63594A
+    .quad 0x03FDB3B68329C59E9  # 0.425500916886 543
+    .quad 0x03FDB3B68329C59E9
+    .quad 0x03FDB44977C148F1A  # 0.426061507389 544
+    .quad 0x03FDB44977C148F1A
+    .quad 0x03FDB50D895F7773A  # 0.426809450580 545
+    .quad 0x03FDB50D895F7773A
+    .quad 0x03FDB5A0AF3D169CD  # 0.427370775322 546
+    .quad 0x03FDB5A0AF3D169CD
+    .quad 0x03FDB66502A41E541  # 0.428119698779 547
+    .quad 0x03FDB66502A41E541
+    .quad 0x03FDB6F859E8EF639  # 0.428681759684 548
+    .quad 0x03FDB6F859E8EF639
+    .quad 0x03FDB78BC664238C0  # 0.429244136679 549
+    .quad 0x03FDB78BC664238C0
+    .quad 0x03FDB85078123E586  # 0.429994464983 550
+    .quad 0x03FDB85078123E586
+    .quad 0x03FDB8E41624226C5  # 0.430557580905 551
+    .quad 0x03FDB8E41624226C5
+    .quad 0x03FDB9A90A06BCB3D  # 0.431308895742 552
+    .quad 0x03FDB9A90A06BCB3D
+    .quad 0x03FDBA3CD9D0B81BD  # 0.431872752537 553
+    .quad 0x03FDBA3CD9D0B81BD
+    .quad 0x03FDBAD0BEF3DB164  # 0.432436927446 554
+    .quad 0x03FDBAD0BEF3DB164
+    .quad 0x03FDBB9611B80E2FC  # 0.433189656123 555
+    .quad 0x03FDBB9611B80E2FC
+    .quad 0x03FDBC2A28C33B75D  # 0.433754574696 556
+    .quad 0x03FDBC2A28C33B75D
+    .quad 0x03FDBCBE553C2BDDF  # 0.434319812582 557
+    .quad 0x03FDBCBE553C2BDDF
+    .quad 0x03FDBD84073D8EC2B  # 0.435073960430 558
+    .quad 0x03FDBD84073D8EC2B
+    .quad 0x03FDBE1865CEC1EC9  # 0.435639944787 559
+    .quad 0x03FDBE1865CEC1EC9
+    .quad 0x03FDBEACD9E271AD1  # 0.436206249662 560
+    .quad 0x03FDBEACD9E271AD1
+    .quad 0x03FDBF72EB7D20355  # 0.436961822044 561
+    .quad 0x03FDBF72EB7D20355
+    .quad 0x03FDC00791D99132B  # 0.437528876213 562
+    .quad 0x03FDC00791D99132B
+    .quad 0x03FDC09C4DCD565AB  # 0.438096252115 563
+    .quad 0x03FDC09C4DCD565AB
+    .quad 0x03FDC162BF5DF23E4  # 0.438853254422 564
+    .quad 0x03FDC162BF5DF23E4
+    .quad 0x03FDC1F7ADCB3DAB0  # 0.439421382456 565
+    .quad 0x03FDC1F7ADCB3DAB0
+    .quad 0x03FDC28CB1E4D32FD  # 0.439989833442 566
+    .quad 0x03FDC28CB1E4D32FD
+    .quad 0x03FDC35383C8850B0  # 0.440748271097 567
+    .quad 0x03FDC35383C8850B0
+    .quad 0x03FDC3E8BA8CACF27  # 0.441317477070 568
+    .quad 0x03FDC3E8BA8CACF27
+    .quad 0x03FDC47E071233744  # 0.441887007223 569
+    .quad 0x03FDC47E071233744
+    .quad 0x03FDC54539A6ABCD2  # 0.442646885679 570
+    .quad 0x03FDC54539A6ABCD2
+    .quad 0x03FDC5DAB908186FF  # 0.443217173690 571
+    .quad 0x03FDC5DAB908186FF
+    .quad 0x03FDC6704E4016FF7  # 0.443787787115 572
+    .quad 0x03FDC6704E4016FF7
+    .quad 0x03FDC737E1E38F4FB  # 0.444549111857 573
+    .quad 0x03FDC737E1E38F4FB
+    .quad 0x03FDC7CDAA290FEAD  # 0.445120486027 574
+    .quad 0x03FDC7CDAA290FEAD
+    .quad 0x03FDC863885A74D16  # 0.445692186852 575
+    .quad 0x03FDC863885A74D16
+    .quad 0x03FDC8F97C7E299DB  # 0.446264214707 576
+    .quad 0x03FDC8F97C7E299DB
+    .quad 0x03FDC9C18EDC7C26B  # 0.447027427871 577
+    .quad 0x03FDC9C18EDC7C26B
+    .quad 0x03FDCA57B64E9DB05  # 0.447600220249 578
+    .quad 0x03FDCA57B64E9DB05
+    .quad 0x03FDCAEDF3C88A364  # 0.448173340907 579
+    .quad 0x03FDCAEDF3C88A364
+    .quad 0x03FDCB844750B9995  # 0.448746790220 580
+    .quad 0x03FDCB844750B9995
+    .quad 0x03FDCC4CD90B3ECE5  # 0.449511901199 581
+    .quad 0x03FDCC4CD90B3ECE5
+    .quad 0x03FDCCE3602341C10  # 0.450086118843 582
+    .quad 0x03FDCCE3602341C10
+    .quad 0x03FDCD79FD5F2BC77  # 0.450660666403 583
+    .quad 0x03FDCD79FD5F2BC77
+    .quad 0x03FDCE10B0C581284  # 0.451235544257 584
+    .quad 0x03FDCE10B0C581284
+    .quad 0x03FDCED9C27EC6607  # 0.452002562511 585
+    .quad 0x03FDCED9C27EC6607
+    .quad 0x03FDCF70A9B6D3810  # 0.452578212532 586
+    .quad 0x03FDCF70A9B6D3810
+    .quad 0x03FDD007A72F19BBC  # 0.453154194116 587
+    .quad 0x03FDD007A72F19BBC
+    .quad 0x03FDD09EBAEE29DD8  # 0.453730507647 588
+    .quad 0x03FDD09EBAEE29DD8
+    .quad 0x03FDD1684D49F46AE  # 0.454499442710 589
+    .quad 0x03FDD1684D49F46AE
+    .quad 0x03FDD1FF951D1F1B3  # 0.455076532271 590
+    .quad 0x03FDD1FF951D1F1B3
+    .quad 0x03FDD296F34D0B65C  # 0.455653955057 591
+    .quad 0x03FDD296F34D0B65C
+    .quad 0x03FDD32E67E056BD5  # 0.456231711452 592
+    .quad 0x03FDD32E67E056BD5
+    .quad 0x03FDD3C5F2DDA1840  # 0.456809801843 593
+    .quad 0x03FDD3C5F2DDA1840
+    .quad 0x03FDD490246DEFA6A  # 0.457581109247 594
+    .quad 0x03FDD490246DEFA6A
+    .quad 0x03FDD527E3D1B95FC  # 0.458159980465 595
+    .quad 0x03FDD527E3D1B95FC
+    .quad 0x03FDD5BFB9B5AE71F  # 0.458739186968 596
+    .quad 0x03FDD5BFB9B5AE71F
+    .quad 0x03FDD657A6207C0DB  # 0.459318729146 597
+    .quad 0x03FDD657A6207C0DB
+    .quad 0x03FDD6EFA918D25CE  # 0.459898607388 598
+    .quad 0x03FDD6EFA918D25CE
+    .quad 0x03FDD7BA7AD9E7DA1  # 0.460672301817 599
+    .quad 0x03FDD7BA7AD9E7DA1
+    .quad 0x03FDD852B28BE5A0F  # 0.461252965726 600
+    .quad 0x03FDD852B28BE5A0F
+    .quad 0x03FDD8EB00E1CCE14  # 0.461833967001 601
+    .quad 0x03FDD8EB00E1CCE14
+    .quad 0x03FDD98365E25ABB9  # 0.462415306035 602
+    .quad 0x03FDD98365E25ABB9
+    .quad 0x03FDDA1BE1944F538  # 0.462996983220 603
+    .quad 0x03FDDA1BE1944F538
+    .quad 0x03FDDAE75484C9615  # 0.463773079495 604
+    .quad 0x03FDDAE75484C9615
+    .quad 0x03FDDB8005445488B  # 0.464355547233 605
+    .quad 0x03FDDB8005445488B
+    .quad 0x03FDDC18CCCBDCB83  # 0.464938354438 606
+    .quad 0x03FDDC18CCCBDCB83
+    .quad 0x03FDDCB1AB222F33D  # 0.465521501504 607
+    .quad 0x03FDDCB1AB222F33D
+    .quad 0x03FDDD4AA04E1C4B7  # 0.466104988830 608
+    .quad 0x03FDDD4AA04E1C4B7
+    .quad 0x03FDDDE3AC56775D2  # 0.466688816812 609
+    .quad 0x03FDDDE3AC56775D2
+    .quad 0x03FDDE7CCF4216D6E  # 0.467272985848 610
+    .quad 0x03FDDE7CCF4216D6E
+    .quad 0x03FDDF492177D7BBC  # 0.468052409114 611
+    .quad 0x03FDDF492177D7BBC
+    .quad 0x03FDDFE279E5BF4EE  # 0.468637375496 612
+    .quad 0x03FDDFE279E5BF4EE
+    .quad 0x03FDE07BE94DCC439  # 0.469222684263 613
+    .quad 0x03FDE07BE94DCC439
+    .quad 0x03FDE1156FB6E2626  # 0.469808335817 614
+    .quad 0x03FDE1156FB6E2626
+    .quad 0x03FDE1AF0D27E88D7  # 0.470394330560 615
+    .quad 0x03FDE1AF0D27E88D7
+    .quad 0x03FDE248C1A7C8C26  # 0.470980668894 616
+    .quad 0x03FDE248C1A7C8C26
+    .quad 0x03FDE2E28D3D701CC  # 0.471567351222 617
+    .quad 0x03FDE2E28D3D701CC
+    .quad 0x03FDE37C6FEFCED73  # 0.472154377948 618
+    .quad 0x03FDE37C6FEFCED73
+    .quad 0x03FDE449C232C39D8  # 0.472937616681 619
+    .quad 0x03FDE449C232C39D8
+    .quad 0x03FDE4E3DAEDDB5F6  # 0.473525448578 620
+    .quad 0x03FDE4E3DAEDDB5F6
+    .quad 0x03FDE57E0ADCE1EA5  # 0.474113626224 621
+    .quad 0x03FDE57E0ADCE1EA5
+    .quad 0x03FDE6185206D516F  # 0.474702150027 622
+    .quad 0x03FDE6185206D516F
+    .quad 0x03FDE6B2B072B5E6F  # 0.475291020395 623
+    .quad 0x03FDE6B2B072B5E6F
+    .quad 0x03FDE74D26278887A  # 0.475880237735 624
+    .quad 0x03FDE74D26278887A
+    .quad 0x03FDE7E7B32C5453F  # 0.476469802457 625
+    .quad 0x03FDE7E7B32C5453F
+    .quad 0x03FDE882578823D52  # 0.477059714970 626
+    .quad 0x03FDE882578823D52
+    .quad 0x03FDE91D134204C67  # 0.477649975686 627
+    .quad 0x03FDE91D134204C67
+    .quad 0x03FDE9B7E6610815A  # 0.478240585015 628
+    .quad 0x03FDE9B7E6610815A
+    .quad 0x03FDEA52D0EC41E5E  # 0.478831543369 629
+    .quad 0x03FDEA52D0EC41E5E
+    .quad 0x03FDEB218376ECFC0  # 0.479620031484 630
+    .quad 0x03FDEB218376ECFC0
+    .quad 0x03FDEBBCA4C4E9E87  # 0.480211805838 631
+    .quad 0x03FDEBBCA4C4E9E87
+    .quad 0x03FDEC57DD96CD0CB  # 0.480803930597 632
+    .quad 0x03FDEC57DD96CD0CB
+    .quad 0x03FDECF32DF3B887D  # 0.481396406174 633
+    .quad 0x03FDECF32DF3B887D
+    .quad 0x03FDED8E95E2D1B88  # 0.481989232987 634
+    .quad 0x03FDED8E95E2D1B88
+    .quad 0x03FDEE2A156B413E5  # 0.482582411453 635
+    .quad 0x03FDEE2A156B413E5
+    .quad 0x03FDEEC5AC9432FCB  # 0.483175941987 636
+    .quad 0x03FDEEC5AC9432FCB
+    .quad 0x03FDEF615B64D61C7  # 0.483769825010 637
+    .quad 0x03FDEF615B64D61C7
+    .quad 0x03FDEFFD21E45D0D1  # 0.484364060939 638
+    .quad 0x03FDEFFD21E45D0D1
+    .quad 0x03FDF0990019FD887  # 0.484958650194 639
+    .quad 0x03FDF0990019FD887
+    .quad 0x03FDF134F60CF092D  # 0.485553593197 640
+    .quad 0x03FDF134F60CF092D
+    .quad 0x03FDF1D103C4727E4  # 0.486148890367 641
+    .quad 0x03FDF1D103C4727E4
+    .quad 0x03FDF26D2947C2EC5  # 0.486744542127 642
+    .quad 0x03FDF26D2947C2EC5
+    .quad 0x03FDF309669E24CF9  # 0.487340548899 643
+    .quad 0x03FDF309669E24CF9
+    .quad 0x03FDF3A5BBCEDE6E1  # 0.487936911107 644
+    .quad 0x03FDF3A5BBCEDE6E1
+    .quad 0x03FDF44228E13963A  # 0.488533629176 645
+    .quad 0x03FDF44228E13963A
+    .quad 0x03FDF4DEADDC82A35  # 0.489130703529 646
+    .quad 0x03FDF4DEADDC82A35
+    .quad 0x03FDF57B4AC80A79A  # 0.489728134594 647
+    .quad 0x03FDF57B4AC80A79A
+    .quad 0x03FDF617FFAB248ED  # 0.490325922795 648
+    .quad 0x03FDF617FFAB248ED
+    .quad 0x03FDF6B4CC8D27E87  # 0.490924068561 649
+    .quad 0x03FDF6B4CC8D27E87
+    .quad 0x03FDF751B1756EEC8  # 0.491522572320 650
+    .quad 0x03FDF751B1756EEC8
+    .quad 0x03FDF7EEAE6B5761C  # 0.492121434499 651
+    .quad 0x03FDF7EEAE6B5761C
+    .quad 0x03FDF88BC3764273B  # 0.492720655530 652
+    .quad 0x03FDF88BC3764273B
+    .quad 0x03FDF928F09D94B32  # 0.493320235842 653
+    .quad 0x03FDF928F09D94B32
+    .quad 0x03FDF9C635E8B6192  # 0.493920175866 654
+    .quad 0x03FDF9C635E8B6192
+    .quad 0x03FDFA63935F1208C  # 0.494520476034 655
+    .quad 0x03FDFA63935F1208C
+    .quad 0x03FDFB0109081751A  # 0.495121136779 656
+    .quad 0x03FDFB0109081751A
+    .quad 0x03FDFB9E96EB38311  # 0.495722158534 657
+    .quad 0x03FDFB9E96EB38311
+    .quad 0x03FDFC3C3D0FEA555  # 0.496323541733 658
+    .quad 0x03FDFC3C3D0FEA555
+    .quad 0x03FDFCD9FB7DA6DEF  # 0.496925286812 659
+    .quad 0x03FDFCD9FB7DA6DEF
+    .quad 0x03FDFD77D23BEA634  # 0.497527394206 660
+    .quad 0x03FDFD77D23BEA634
+    .quad 0x03FDFE15C15234EE2  # 0.498129864352 661
+    .quad 0x03FDFE15C15234EE2
+    .quad 0x03FDFEB3C8C80A04E  # 0.498732697687 662
+    .quad 0x03FDFEB3C8C80A04E
+    .quad 0x03FDFF51E8A4F0A74  # 0.499335894649 663
+    .quad 0x03FDFF51E8A4F0A74
+    .quad 0x03FDFFF020F07352E  # 0.499939455677 664
+    .quad 0x03FDFFF020F07352E
+    .quad 0x03FE004738D910023  # 0.500543381211 665
+    .quad 0x03FE004738D910023
+    .quad 0x03FE00966D78C41CF  # 0.501147671692 666
+    .quad 0x03FE00966D78C41CF
+    .quad 0x03FE00E5AE5B207AB  # 0.501752327560 667
+    .quad 0x03FE00E5AE5B207AB
+    .quad 0x03FE011A8B18F0ED6  # 0.502155634684 668
+    .quad 0x03FE011A8B18F0ED6
+    .quad 0x03FE0169E072D7311  # 0.502760900515 669
+    .quad 0x03FE0169E072D7311
+    .quad 0x03FE01B942198A5A1  # 0.503366532915 670
+    .quad 0x03FE01B942198A5A1
+    .quad 0x03FE0208B010DB642  # 0.503972532327 671
+    .quad 0x03FE0208B010DB642
+    .quad 0x03FE02582A5C9D122  # 0.504578899198 672
+    .quad 0x03FE02582A5C9D122
+    .quad 0x03FE02A7B100A3EF0  # 0.505185633972 673
+    .quad 0x03FE02A7B100A3EF0
+    .quad 0x03FE02F74400C64EA  # 0.505792737097 674
+    .quad 0x03FE02F74400C64EA
+    .quad 0x03FE0346E360DC4F9  # 0.506400209020 675
+    .quad 0x03FE0346E360DC4F9
+    .quad 0x03FE03968F24BFDB6  # 0.507008050190 676
+    .quad 0x03FE03968F24BFDB6
+    .quad 0x03FE03E647504CA89  # 0.507616261055 677
+    .quad 0x03FE03E647504CA89
+    .quad 0x03FE04360BE7603AE  # 0.508224842066 678
+    .quad 0x03FE04360BE7603AE
+    .quad 0x03FE046B4089BE0FD  # 0.508630768599 679
+    .quad 0x03FE046B4089BE0FD
+    .quad 0x03FE04BB19DCA36B3  # 0.509239967521 680
+    .quad 0x03FE04BB19DCA36B3
+    .quad 0x03FE050AFFA5671A5  # 0.509849537793 681
+    .quad 0x03FE050AFFA5671A5
+    .quad 0x03FE055AF1E7ED47B  # 0.510459479867 682
+    .quad 0x03FE055AF1E7ED47B
+    .quad 0x03FE05AAF0A81BF04  # 0.511069794198 683
+    .quad 0x03FE05AAF0A81BF04
+    .quad 0x03FE05FAFBE9DAE58  # 0.511680481240 684
+    .quad 0x03FE05FAFBE9DAE58
+    .quad 0x03FE064B13B113CDD  # 0.512291541448 685
+    .quad 0x03FE064B13B113CDD
+    .quad 0x03FE069B3801B2263  # 0.512902975280 686
+    .quad 0x03FE069B3801B2263
+    .quad 0x03FE06D0AC85B63A2  # 0.513310805628 687
+    .quad 0x03FE06D0AC85B63A2
+    .quad 0x03FE0720E5C40DF1D  # 0.513922863181 688
+    .quad 0x03FE0720E5C40DF1D
+    .quad 0x03FE07712B9648153  # 0.514535295577 689
+    .quad 0x03FE07712B9648153
+    .quad 0x03FE07C17E0056E7C  # 0.515148103277 690
+    .quad 0x03FE07C17E0056E7C
+    .quad 0x03FE0811DD062E889  # 0.515761286740 691
+    .quad 0x03FE0811DD062E889
+    .quad 0x03FE086248ABC4F3B  # 0.516374846428 692
+    .quad 0x03FE086248ABC4F3B
+    .quad 0x03FE08B2C0F512033  # 0.516988782802 693
+    .quad 0x03FE08B2C0F512033
+    .quad 0x03FE08E86D82DA3EE  # 0.517398283218 694
+    .quad 0x03FE08E86D82DA3EE
+    .quad 0x03FE0938FAE5D8E9B  # 0.518012848432 695
+    .quad 0x03FE0938FAE5D8E9B
+    .quad 0x03FE098994F72C539  # 0.518627791569 696
+    .quad 0x03FE098994F72C539
+    .quad 0x03FE09DA3BBAD339C  # 0.519243113094 697
+    .quad 0x03FE09DA3BBAD339C
+    .quad 0x03FE0A2AEF34CE3D1  # 0.519858813473 698
+    .quad 0x03FE0A2AEF34CE3D1
+    .quad 0x03FE0A7BAF691FE34  # 0.520474893172 699
+    .quad 0x03FE0A7BAF691FE34
+    .quad 0x03FE0AB18BF5823C3  # 0.520885823936 700
+    .quad 0x03FE0AB18BF5823C3
+    .quad 0x03FE0B02616952989  # 0.521502536876 701
+    .quad 0x03FE0B02616952989
+    .quad 0x03FE0B5343A234476  # 0.522119630385 702
+    .quad 0x03FE0B5343A234476
+    .quad 0x03FE0BA432A430CA2  # 0.522737104934 703
+    .quad 0x03FE0BA432A430CA2
+    .quad 0x03FE0BF52E73538CE  # 0.523354960993 704
+    .quad 0x03FE0BF52E73538CE
+    .quad 0x03FE0C463713A9E6F  # 0.523973199034 705
+    .quad 0x03FE0C463713A9E6F
+    .quad 0x03FE0C7C43F4C861E  # 0.524385570174 706
+    .quad 0x03FE0C7C43F4C861E
+    .quad 0x03FE0CCD61FAD07D2  # 0.525004445903 707
+    .quad 0x03FE0CCD61FAD07D2
+    .quad 0x03FE0D1E8CDCE3DB6  # 0.525623704876 708
+    .quad 0x03FE0D1E8CDCE3DB6
+    .quad 0x03FE0D6FC49F16E93  # 0.526243347569 709
+    .quad 0x03FE0D6FC49F16E93
+    .quad 0x03FE0DC109458004A  # 0.526863374456 710
+    .quad 0x03FE0DC109458004A
+    .quad 0x03FE0DF73E353F0ED  # 0.527276939392 711
+    .quad 0x03FE0DF73E353F0ED
+    .quad 0x03FE0E4898611CCE1  # 0.527897607665 712
+    .quad 0x03FE0E4898611CCE1
+    .quad 0x03FE0E99FF7C20738  # 0.528518661406 713
+    .quad 0x03FE0E99FF7C20738
+    .quad 0x03FE0EEB738A67874  # 0.529140101094 714
+    .quad 0x03FE0EEB738A67874
+    .quad 0x03FE0F21C81D1ADC3  # 0.529554608872 715
+    .quad 0x03FE0F21C81D1ADC3
+    .quad 0x03FE0F7351C9FCD7F  # 0.530176692874 716
+    .quad 0x03FE0F7351C9FCD7F
+    .quad 0x03FE0FC4E875254C1  # 0.530799164104 717
+    .quad 0x03FE0FC4E875254C1
+    .quad 0x03FE10168C22B8FB9  # 0.531422023047 718
+    .quad 0x03FE10168C22B8FB9
+    .quad 0x03FE10683CD6DEA54  # 0.532045270185 719
+    .quad 0x03FE10683CD6DEA54
+    .quad 0x03FE109EB9E2E4C97  # 0.532460984179 720
+    .quad 0x03FE109EB9E2E4C97
+    .quad 0x03FE10F08055E7785  # 0.533084879385 721
+    .quad 0x03FE10F08055E7785
+    .quad 0x03FE114253DA97DA0  # 0.533709164079 722
+    .quad 0x03FE114253DA97DA0
+    .quad 0x03FE1194347523FDC  # 0.534333838748 723
+    .quad 0x03FE1194347523FDC
+    .quad 0x03FE11CAD1789B0F8  # 0.534750505421 724
+    .quad 0x03FE11CAD1789B0F8
+    .quad 0x03FE121CC7EB8F7E6  # 0.535375831132 725
+    .quad 0x03FE121CC7EB8F7E6
+    .quad 0x03FE126ECB7F8F007  # 0.536001548120 726
+    .quad 0x03FE126ECB7F8F007
+    .quad 0x03FE12A57FDA37091  # 0.536418910396 727
+    .quad 0x03FE12A57FDA37091
+    .quad 0x03FE12F799594EFBC  # 0.537045280601 728
+    .quad 0x03FE12F799594EFBC
+    .quad 0x03FE1349C004AFB00  # 0.537672043392 729
+    .quad 0x03FE1349C004AFB00
+    .quad 0x03FE139BF3E094003  # 0.538299199261 730
+    .quad 0x03FE139BF3E094003
+    .quad 0x03FE13D2C873C5E13  # 0.538717521794 731
+    .quad 0x03FE13D2C873C5E13
+    .quad 0x03FE142512549C16C  # 0.539345333889 732
+    .quad 0x03FE142512549C16C
+    .quad 0x03FE14776971477F1  # 0.539973540381 733
+    .quad 0x03FE14776971477F1
+    .quad 0x03FE14C9CDCE0A74D  # 0.540602141763 734
+    .quad 0x03FE14C9CDCE0A74D
+    .quad 0x03FE1500C2BFD1561  # 0.541021428981 735
+    .quad 0x03FE1500C2BFD1561
+    .quad 0x03FE15533D3B8D7B3  # 0.541650689621 736
+    .quad 0x03FE15533D3B8D7B3
+    .quad 0x03FE15A5C502C6DC5  # 0.542280346478 737
+    .quad 0x03FE15A5C502C6DC5
+    .quad 0x03FE15DCD1973457B  # 0.542700338085 738
+    .quad 0x03FE15DCD1973457B
+    .quad 0x03FE162F6F9071F76  # 0.543330656416 739
+    .quad 0x03FE162F6F9071F76
+    .quad 0x03FE16821AE0A13C6  # 0.543961372300 740
+    .quad 0x03FE16821AE0A13C6
+    .quad 0x03FE16B93F2C12808  # 0.544382070665 741
+    .quad 0x03FE16B93F2C12808
+    .quad 0x03FE170C00C169B51  # 0.545013450251 742
+    .quad 0x03FE170C00C169B51
+    .quad 0x03FE175ECFB935CC6  # 0.545645228728 743
+    .quad 0x03FE175ECFB935CC6
+    .quad 0x03FE17B1AC17CBD5B  # 0.546277406602 744
+    .quad 0x03FE17B1AC17CBD5B
+    .quad 0x03FE17E8F12052E8A  # 0.546699080654 745
+    .quad 0x03FE17E8F12052E8A
+    .quad 0x03FE183BE3DE8A7AF  # 0.547331925312 746
+    .quad 0x03FE183BE3DE8A7AF
+    .quad 0x03FE188EE40F23CA7  # 0.547965170715 747
+    .quad 0x03FE188EE40F23CA7
+    .quad 0x03FE18C640FF75F06  # 0.548387557205 748
+    .quad 0x03FE18C640FF75F06
+    .quad 0x03FE191957A30FA51  # 0.549021471648 749
+    .quad 0x03FE191957A30FA51
+    .quad 0x03FE196C7BC4B1F3A  # 0.549655788193 750
+    .quad 0x03FE196C7BC4B1F3A
+    .quad 0x03FE19A3F0B1860BD  # 0.550078889532 751
+    .quad 0x03FE19A3F0B1860BD
+    .quad 0x03FE19F72B59A0CEC  # 0.550713877383 752
+    .quad 0x03FE19F72B59A0CEC
+    .quad 0x03FE1A4A738B7A33C  # 0.551349268700 753
+    .quad 0x03FE1A4A738B7A33C
+    .quad 0x03FE1A820089A2156  # 0.551773087312 754
+    .quad 0x03FE1A820089A2156
+    .quad 0x03FE1AD55F55855C8  # 0.552409152212 755
+    .quad 0x03FE1AD55F55855C8
+    .quad 0x03FE1B28CBB6EC93E  # 0.553045621948 756
+    .quad 0x03FE1B28CBB6EC93E
+    .quad 0x03FE1B6070DB553D8  # 0.553470160269 757
+    .quad 0x03FE1B6070DB553D8
+    .quad 0x03FE1BB3F3EA714F6  # 0.554107305878 758
+    .quad 0x03FE1BB3F3EA714F6
+    .quad 0x03FE1BEBA8316EF2C  # 0.554532295260 759
+    .quad 0x03FE1BEBA8316EF2C
+    .quad 0x03FE1C3F41FA97C6B  # 0.555170118179 760
+    .quad 0x03FE1C3F41FA97C6B
+    .quad 0x03FE1C92E96C86020  # 0.555808348176 761
+    .quad 0x03FE1C92E96C86020
+    .quad 0x03FE1CCAB5FBFFEE1  # 0.556234061252 762
+    .quad 0x03FE1CCAB5FBFFEE1
+    .quad 0x03FE1D1E743BCFC47  # 0.556872970868 763
+    .quad 0x03FE1D1E743BCFC47
+    .quad 0x03FE1D72403052E75  # 0.557512288951 764
+    .quad 0x03FE1D72403052E75
+    .quad 0x03FE1DAA251D7E433  # 0.557938728190 765
+    .quad 0x03FE1DAA251D7E433
+    .quad 0x03FE1DFE07F3D1DAB  # 0.558578728212 766
+    .quad 0x03FE1DFE07F3D1DAB
+    .quad 0x03FE1E35FC265D75E  # 0.559005622562 767
+    .quad 0x03FE1E35FC265D75E
+    .quad 0x03FE1E89F5EB04126  # 0.559646305979 768
+    .quad 0x03FE1E89F5EB04126
+    .quad 0x03FE1EDDFD77E1FEF  # 0.560287400135 769
+    .quad 0x03FE1EDDFD77E1FEF
+    .quad 0x03FE1F160A2AD0DA3  # 0.560715024687 770
+    .quad 0x03FE1F160A2AD0DA3
+    .quad 0x03FE1F6A28BA1B476  # 0.561356804579 771
+    .quad 0x03FE1F6A28BA1B476
+    .quad 0x03FE1FBE551DB43C1  # 0.561998996616 772
+    .quad 0x03FE1FBE551DB43C1
+    .quad 0x03FE1FF67A6684F47  # 0.562427353873 773
+    .quad 0x03FE1FF67A6684F47
+    .quad 0x03FE204ABDE0BE5DF  # 0.563070233998 774
+    .quad 0x03FE204ABDE0BE5DF
+    .quad 0x03FE2082F29233211  # 0.563499050471 775
+    .quad 0x03FE2082F29233211
+    .quad 0x03FE20D74D2FBAFE4  # 0.564142620160 776
+    .quad 0x03FE20D74D2FBAFE4
+    .quad 0x03FE210F91524B469  # 0.564571896835 777
+    .quad 0x03FE210F91524B469
+    .quad 0x03FE2164031FDA0B0  # 0.565216157568 778
+    .quad 0x03FE2164031FDA0B0
+    .quad 0x03FE21B882DD26040  # 0.565860833641 779
+    .quad 0x03FE21B882DD26040
+    .quad 0x03FE21F0DFC65CEEC  # 0.566290848698 780
+    .quad 0x03FE21F0DFC65CEEC
+    .quad 0x03FE224576C81FFE0  # 0.566936218194 781
+    .quad 0x03FE224576C81FFE0
+    .quad 0x03FE227DE33896A44  # 0.567366696031 782
+    .quad 0x03FE227DE33896A44
+    .quad 0x03FE22D2918BA4A31  # 0.568012760445 783
+    .quad 0x03FE22D2918BA4A31
+    .quad 0x03FE23274DE272A83  # 0.568659242528 784
+    .quad 0x03FE23274DE272A83
+    .quad 0x03FE235FD33D232FC  # 0.569090462888 785
+    .quad 0x03FE235FD33D232FC
+    .quad 0x03FE23B4A6F9D8688  # 0.569737642287 786
+    .quad 0x03FE23B4A6F9D8688
+    .quad 0x03FE23ED3BF21CA33  # 0.570169328026 787
+    .quad 0x03FE23ED3BF21CA33
+    .quad 0x03FE24422721A89D7  # 0.570817206248 788
+    .quad 0x03FE24422721A89D7
+    .quad 0x03FE247ACBC023D2B  # 0.571249358372 789
+    .quad 0x03FE247ACBC023D2B
+    .quad 0x03FE24CFCE6F80D9B  # 0.571897936927 790
+    .quad 0x03FE24CFCE6F80D9B
+    .quad 0x03FE250882BCDD7D8  # 0.572330556445 791
+    .quad 0x03FE250882BCDD7D8
+    .quad 0x03FE255D9CF910A56  # 0.572979836849 792
+    .quad 0x03FE255D9CF910A56
+    .quad 0x03FE25B2C55CD5762  # 0.573629539091 793
+    .quad 0x03FE25B2C55CD5762
+    .quad 0x03FE25EB92D41992D  # 0.574062908546 794
+    .quad 0x03FE25EB92D41992D
+    .quad 0x03FE2640D2D99FFEA  # 0.574713315073 795
+    .quad 0x03FE2640D2D99FFEA
+    .quad 0x03FE2679B0166F51C  # 0.575147154559 796
+    .quad 0x03FE2679B0166F51C
+    .quad 0x03FE26CF07CAD8B00  # 0.575798266899 797
+    .quad 0x03FE26CF07CAD8B00
+    .quad 0x03FE2707F4D5F7C40  # 0.576232577438 798
+    .quad 0x03FE2707F4D5F7C40
+    .quad 0x03FE275D644670606  # 0.576884397124 799
+    .quad 0x03FE275D644670606
+    .quad 0x03FE27966128AB11B  # 0.577319179739 800
+    .quad 0x03FE27966128AB11B
+    .quad 0x03FE27EBE8626A387  # 0.577971708311 801
+    .quad 0x03FE27EBE8626A387
+    .quad 0x03FE2824F52493BD2  # 0.578406964030 802
+    .quad 0x03FE2824F52493BD2
+    .quad 0x03FE287A9434DBC7B  # 0.579060203030 803
+    .quad 0x03FE287A9434DBC7B
+    .quad 0x03FE28B3B0DFCEB80  # 0.579495932884 804
+    .quad 0x03FE28B3B0DFCEB80
+    .quad 0x03FE290967D3ED18D  # 0.580149883861 805
+    .quad 0x03FE290967D3ED18D
+    .quad 0x03FE294294708B773  # 0.580586088885 806
+    .quad 0x03FE294294708B773
+    .quad 0x03FE29986355D8C69  # 0.581240753393 807
+    .quad 0x03FE29986355D8C69
+    .quad 0x03FE29D19FED0C082  # 0.581677434622 808
+    .quad 0x03FE29D19FED0C082
+    .quad 0x03FE2A2786D0EC107  # 0.582332814220 809
+    .quad 0x03FE2A2786D0EC107
+    .quad 0x03FE2A60D36BA5253  # 0.582769972697 810
+    .quad 0x03FE2A60D36BA5253
+    .quad 0x03FE2AB6D25B86EF7  # 0.583426068948 811
+    .quad 0x03FE2AB6D25B86EF7
+    .quad 0x03FE2AF02F02BE4AB  # 0.583863705716 812
+    .quad 0x03FE2AF02F02BE4AB
+    .quad 0x03FE2B46460C1C2B3  # 0.584520520190 813
+    .quad 0x03FE2B46460C1C2B3
+    .quad 0x03FE2B7FB2C8D1CC1  # 0.584958636297 814
+    .quad 0x03FE2B7FB2C8D1CC1
+    .quad 0x03FE2BD5E1F9316F2  # 0.585616170568 815
+    .quad 0x03FE2BD5E1F9316F2
+    .quad 0x03FE2C0F5ED46CE8D  # 0.586054767066 816
+    .quad 0x03FE2C0F5ED46CE8D
+    .quad 0x03FE2C65A6395F5F5  # 0.586713022712 817
+    .quad 0x03FE2C65A6395F5F5
+    .quad 0x03FE2C9F333C2FE1E  # 0.587152100656 818
+    .quad 0x03FE2C9F333C2FE1E
+    .quad 0x03FE2CF592E351AE5  # 0.587811079263 819
+    .quad 0x03FE2CF592E351AE5
+    .quad 0x03FE2D2F3016CE0EF  # 0.588250639709 820
+    .quad 0x03FE2D2F3016CE0EF
+    .quad 0x03FE2D85A80DC7324  # 0.588910342867 821
+    .quad 0x03FE2D85A80DC7324
+    .quad 0x03FE2DBF557B0DF43  # 0.589350386878 822
+    .quad 0x03FE2DBF557B0DF43
+    .quad 0x03FE2E15E5CF91FA7  # 0.590010816181 823
+    .quad 0x03FE2E15E5CF91FA7
+    .quad 0x03FE2E4FA37FC9577  # 0.590451344823 824
+    .quad 0x03FE2E4FA37FC9577
+    .quad 0x03FE2E8967B3BF4E1  # 0.590892067615 825
+    .quad 0x03FE2E8967B3BF4E1
+    .quad 0x03FE2EE01A3BED567  # 0.591553516212 826
+    .quad 0x03FE2EE01A3BED567
+    .quad 0x03FE2F19EEBFB00BA  # 0.591994725131 827
+    .quad 0x03FE2F19EEBFB00BA
+    .quad 0x03FE2F70B9C67A7C2  # 0.592656903723 828
+    .quad 0x03FE2F70B9C67A7C2
+    .quad 0x03FE2FAA9EA342D04  # 0.593098599843 829
+    .quad 0x03FE2FAA9EA342D04
+    .quad 0x03FE3001823684D73  # 0.593761510043 830
+    .quad 0x03FE3001823684D73
+    .quad 0x03FE303B7775937EF  # 0.594203694441 831
+    .quad 0x03FE303B7775937EF
+    .quad 0x03FE309273A3340FC  # 0.594867337868 832
+    .quad 0x03FE309273A3340FC
+    .quad 0x03FE30CC794DD19D0  # 0.595310011625 833
+    .quad 0x03FE30CC794DD19D0
+    .quad 0x03FE3106858C76BB7  # 0.595752881428 834
+    .quad 0x03FE3106858C76BB7
+    .quad 0x03FE315DA4434068B  # 0.596417554101 835
+    .quad 0x03FE315DA4434068B
+    .quad 0x03FE3197C0FA80E6A  # 0.596860914783 836
+    .quad 0x03FE3197C0FA80E6A
+    .quad 0x03FE31EEF86D36EF1  # 0.597526324589 837
+    .quad 0x03FE31EEF86D36EF1
+    .quad 0x03FE322925A66E62D  # 0.597970177237 838
+    .quad 0x03FE322925A66E62D
+    .quad 0x03FE328075E32022F  # 0.598636325813 839
+    .quad 0x03FE328075E32022F
+    .quad 0x03FE32BAB3A7B21E9  # 0.599080671521 840
+    .quad 0x03FE32BAB3A7B21E9
+    .quad 0x03FE32F4F80D0B1BD  # 0.599525214760 841
+    .quad 0x03FE32F4F80D0B1BD
+    .quad 0x03FE334C6B15D30DD  # 0.600192400374 842
+    .quad 0x03FE334C6B15D30DD
+    .quad 0x03FE3386C013B90D6  # 0.600637438209 843
+    .quad 0x03FE3386C013B90D6
+    .quad 0x03FE33DE4C086C40A  # 0.601305366543 844
+    .quad 0x03FE33DE4C086C40A
+    .quad 0x03FE3418B1A85622C  # 0.601750900077 845
+    .quad 0x03FE3418B1A85622C
+    .quad 0x03FE34531DF21CFE3  # 0.602196632199 846
+    .quad 0x03FE34531DF21CFE3
+    .quad 0x03FE34AACCE299BA5  # 0.602865603124 847
+    .quad 0x03FE34AACCE299BA5
+    .quad 0x03FE34E549DBB21EF  # 0.603311832493 848
+    .quad 0x03FE34E549DBB21EF
+    .quad 0x03FE353D11DA4F855  # 0.603981550121 849
+    .quad 0x03FE353D11DA4F855
+    .quad 0x03FE35779F8C43D6D  # 0.604428277847 850
+    .quad 0x03FE35779F8C43D6D
+    .quad 0x03FE35B233F13DD4A  # 0.604875205229 851
+    .quad 0x03FE35B233F13DD4A
+    .quad 0x03FE360A1F1BBA738  # 0.605545971045 852
+    .quad 0x03FE360A1F1BBA738
+    .quad 0x03FE3644C446F97BC  # 0.605993398346 853
+    .quad 0x03FE3644C446F97BC
+    .quad 0x03FE367F702A9EA94  # 0.606441025927 854
+    .quad 0x03FE367F702A9EA94
+    .quad 0x03FE36D77E9D34FD7  # 0.607112843218 855
+    .quad 0x03FE36D77E9D34FD7
+    .quad 0x03FE37123B54987B7  # 0.607560972287 856
+    .quad 0x03FE37123B54987B7
+    .quad 0x03FE376A630C0A1D6  # 0.608233542652 857
+    .quad 0x03FE376A630C0A1D6
+    .quad 0x03FE37A530A0D5A31  # 0.608682174333 858
+    .quad 0x03FE37A530A0D5A31
+    .quad 0x03FE37E004F74E13B  # 0.609131007374 859
+    .quad 0x03FE37E004F74E13B
+    .quad 0x03FE383850278CFD9  # 0.609804634884 860
+    .quad 0x03FE383850278CFD9
+    .quad 0x03FE3873356902AB7  # 0.610253972119 861
+    .quad 0x03FE3873356902AB7
+    .quad 0x03FE38AE2171976E8  # 0.610703511349 862
+    .quad 0x03FE38AE2171976E8
+    .quad 0x03FE390690373AFFF  # 0.611378199331 863
+    .quad 0x03FE390690373AFFF
+    .quad 0x03FE39418D3872A53  # 0.611828244343 864
+    .quad 0x03FE39418D3872A53
+    .quad 0x03FE397C91064221F  # 0.612278491987 865
+    .quad 0x03FE397C91064221F
+    .quad 0x03FE39D5237E045A5  # 0.612954243787 866
+    .quad 0x03FE39D5237E045A5
+    .quad 0x03FE3A1038522CE82  # 0.613404998809 867
+    .quad 0x03FE3A1038522CE82
+    .quad 0x03FE3A68E45AD354B  # 0.614081512534 868
+    .quad 0x03FE3A68E45AD354B
+    .quad 0x03FE3AA40A3F2A68B  # 0.614532776080 869
+    .quad 0x03FE3AA40A3F2A68B
+    .quad 0x03FE3ADF36F98A182  # 0.614984243356 870
+    .quad 0x03FE3ADF36F98A182
+    .quad 0x03FE3B3806E5DF340  # 0.615661826668 871
+    .quad 0x03FE3B3806E5DF340
+    .quad 0x03FE3B7344BE40311  # 0.616113804077 872
+    .quad 0x03FE3B7344BE40311
+    .quad 0x03FE3BAE897234A87  # 0.616565985862 873
+    .quad 0x03FE3BAE897234A87
+    .quad 0x03FE3C077D5F51881  # 0.617244642149 874
+    .quad 0x03FE3C077D5F51881
+    .quad 0x03FE3C42D33F2AE7B  # 0.617697335683 875
+    .quad 0x03FE3C42D33F2AE7B
+    .quad 0x03FE3C7E30002960C  # 0.618150234241 876
+    .quad 0x03FE3C7E30002960C
+    .quad 0x03FE3CD7480B4A8A3  # 0.618829966906 877
+    .quad 0x03FE3CD7480B4A8A3
+    .quad 0x03FE3D12B60622748  # 0.619283378838 878
+    .quad 0x03FE3D12B60622748
+    .quad 0x03FE3D4E2AE7B7E2B  # 0.619736996447 879
+    .quad 0x03FE3D4E2AE7B7E2B
+    .quad 0x03FE3D89A6B1A558D  # 0.620190819917 880
+    .quad 0x03FE3D89A6B1A558D
+    .quad 0x03FE3DE2ED57B1F9B  # 0.620871941524 881
+    .quad 0x03FE3DE2ED57B1F9B
+    .quad 0x03FE3E1E7A6D8330E  # 0.621326280468 882
+    .quad 0x03FE3E1E7A6D8330E
+    .quad 0x03FE3E5A0E714DA6E  # 0.621780825931 883
+    .quad 0x03FE3E5A0E714DA6E
+    .quad 0x03FE3EB37978B85B6  # 0.622463031756 884
+    .quad 0x03FE3EB37978B85B6
+    .quad 0x03FE3EEF1ED68236B  # 0.622918094335 885
+    .quad 0x03FE3EEF1ED68236B
+    .quad 0x03FE3F2ACB27ED6C7  # 0.623373364090 886
+    .quad 0x03FE3F2ACB27ED6C7
+    .quad 0x03FE3F845AAE68C81  # 0.624056657591 887
+    .quad 0x03FE3F845AAE68C81
+    .quad 0x03FE3FC0186800514  # 0.624512446113 888
+    .quad 0x03FE3FC0186800514
+    .quad 0x03FE3FFBDD1AE8406  # 0.624968442473 889
+    .quad 0x03FE3FFBDD1AE8406
+    .quad 0x03FE4037A8C8C197A  # 0.625424646860 890
+    .quad 0x03FE4037A8C8C197A
+    .quad 0x03FE409167679DD99  # 0.626109343909 891
+    .quad 0x03FE409167679DD99
+    .quad 0x03FE40CD448FF6DD6  # 0.626566069196 892
+    .quad 0x03FE40CD448FF6DD6
+    .quad 0x03FE410928B8F950F  # 0.627023003177 893
+    .quad 0x03FE410928B8F950F
+    .quad 0x03FE41630C1B50AFF  # 0.627708795866 894
+    .quad 0x03FE41630C1B50AFF
+    .quad 0x03FE419F01CD27AD0  # 0.628166252416 895
+    .quad 0x03FE419F01CD27AD0
+    .quad 0x03FE41DAFE85672B9  # 0.628623918328 896
+    .quad 0x03FE41DAFE85672B9
+    .quad 0x03FE42170245B4C6A  # 0.629081793794 897
+    .quad 0x03FE42170245B4C6A
+    .quad 0x03FE42711518DF546  # 0.629769000326 898
+    .quad 0x03FE42711518DF546
+    .quad 0x03FE42AD2A74888A0  # 0.630227400518 899
+    .quad 0x03FE42AD2A74888A0
+    .quad 0x03FE42E946DE080C0  # 0.630686010936 900
+    .quad 0x03FE42E946DE080C0
+    .quad 0x03FE43437EB9D9424  # 0.631374321162 901
+    .quad 0x03FE43437EB9D9424
+    .quad 0x03FE437FACCD31C10  # 0.631833457993 902
+    .quad 0x03FE437FACCD31C10
+    .quad 0x03FE43BBE1F42FE09  # 0.632292805727 903
+    .quad 0x03FE43BBE1F42FE09
+    .quad 0x03FE43F81E307DE5E  # 0.632752364559 904
+    .quad 0x03FE43F81E307DE5E
+    .quad 0x03FE445285D68EA69  # 0.633442099038 905
+    .quad 0x03FE445285D68EA69
+    .quad 0x03FE448ED3CF71355  # 0.633902186463 906
+    .quad 0x03FE448ED3CF71355
+    .quad 0x03FE44CB28E37C3EE  # 0.634362485666 907
+    .quad 0x03FE44CB28E37C3EE
+    .quad 0x03FE450785145CAFE  # 0.634822996841 908
+    .quad 0x03FE450785145CAFE
+    .quad 0x03FE45621CB769366  # 0.635514161481 909
+    .quad 0x03FE45621CB769366
+    .quad 0x03FE459E8AB7B799D  # 0.635975203444 910
+    .quad 0x03FE459E8AB7B799D
+    .quad 0x03FE45DAFFDABD4DB  # 0.636436458065 911
+    .quad 0x03FE45DAFFDABD4DB
+    .quad 0x03FE46177C2229EC0  # 0.636897925539 912
+    .quad 0x03FE46177C2229EC0
+    .quad 0x03FE467243F53F69E  # 0.637590526283 913
+    .quad 0x03FE467243F53F69E
+    .quad 0x03FE46AED21F117FC  # 0.638052526753 914
+    .quad 0x03FE46AED21F117FC
+    .quad 0x03FE46EB677335D13  # 0.638514740766 915
+    .quad 0x03FE46EB677335D13
+    .quad 0x03FE472803F35EAAE  # 0.638977168520 916
+    .quad 0x03FE472803F35EAAE
+    .quad 0x03FE4764A7A13EF3B  # 0.639439810212 917
+    .quad 0x03FE4764A7A13EF3B
+    .quad 0x03FE47BFAA9F80271  # 0.640134174319 918
+    .quad 0x03FE47BFAA9F80271
+    .quad 0x03FE47FC60471DAF8  # 0.640597351724 919
+    .quad 0x03FE47FC60471DAF8
+    .quad 0x03FE48391D226992D  # 0.641060743762 920
+    .quad 0x03FE48391D226992D
+    .quad 0x03FE4875E1331971E  # 0.641524350631 921
+    .quad 0x03FE4875E1331971E
+    .quad 0x03FE48D114D3FB884  # 0.642220164181 922
+    .quad 0x03FE48D114D3FB884
+    .quad 0x03FE490DEAF1A3FC8  # 0.642684309003 923
+    .quad 0x03FE490DEAF1A3FC8
+    .quad 0x03FE494AC84AB0ED3  # 0.643148669355 924
+    .quad 0x03FE494AC84AB0ED3
+    .quad 0x03FE4987ACE0DABB0  # 0.643613245438 925
+    .quad 0x03FE4987ACE0DABB0
+    .quad 0x03FE49C498B5DA63F  # 0.644078037452 926
+    .quad 0x03FE49C498B5DA63F
+    .quad 0x03FE4A20080EF10B2  # 0.644775630783 927
+    .quad 0x03FE4A20080EF10B2
+    .quad 0x03FE4A5D060894B8C  # 0.645240963504 928
+    .quad 0x03FE4A5D060894B8C
+    .quad 0x03FE4A9A0B471A943  # 0.645706512861 929
+    .quad 0x03FE4A9A0B471A943
+    .quad 0x03FE4AD717CC3E626  # 0.646172279055 930
+    .quad 0x03FE4AD717CC3E626
+    .quad 0x03FE4B142B99BC871  # 0.646638262288 931
+    .quad 0x03FE4B142B99BC871
+    .quad 0x03FE4B6FD6F970C1F  # 0.647337644529 932
+    .quad 0x03FE4B6FD6F970C1F
+    .quad 0x03FE4BACFD036D080  # 0.647804171246 933
+    .quad 0x03FE4BACFD036D080
+    .quad 0x03FE4BEA2A5BDBE87  # 0.648270915712 934
+    .quad 0x03FE4BEA2A5BDBE87
+    .quad 0x03FE4C275F047C956  # 0.648737878130 935
+    .quad 0x03FE4C275F047C956
+    .quad 0x03FE4C649AFF0EE16  # 0.649205058703 936
+    .quad 0x03FE4C649AFF0EE16
+    .quad 0x03FE4CC082B46485A  # 0.649906239052 937
+    .quad 0x03FE4CC082B46485A
+    .quad 0x03FE4CFDD1037E37C  # 0.650373965908 938
+    .quad 0x03FE4CFDD1037E37C
+    .quad 0x03FE4D3B26AAADDD9  # 0.650841911635 939
+    .quad 0x03FE4D3B26AAADDD9
+    .quad 0x03FE4D7883ABB61F6  # 0.651310076438 940
+    .quad 0x03FE4D7883ABB61F6
+    .quad 0x03FE4DB5E8085A477  # 0.651778460521 941
+    .quad 0x03FE4DB5E8085A477
+    .quad 0x03FE4DF353C25E42B  # 0.652247064091 942
+    .quad 0x03FE4DF353C25E42B
+    .quad 0x03FE4E4F832C560DD  # 0.652950381434 943
+    .quad 0x03FE4E4F832C560DD
+    .quad 0x03FE4E8D015786F16  # 0.653419534621 944
+    .quad 0x03FE4E8D015786F16
+    .quad 0x03FE4ECA86E64A683  # 0.653888908016 945
+    .quad 0x03FE4ECA86E64A683
+    .quad 0x03FE4F0813DA673DD  # 0.654358501826 946
+    .quad 0x03FE4F0813DA673DD
+    .quad 0x03FE4F45A835A4E19  # 0.654828316258 947
+    .quad 0x03FE4F45A835A4E19
+    .quad 0x03FE4F8343F9CB678  # 0.655298351519 948
+    .quad 0x03FE4F8343F9CB678
+    .quad 0x03FE4FDFBB88A119A  # 0.656003818920 949
+    .quad 0x03FE4FDFBB88A119A
+    .quad 0x03FE501D69DADD660  # 0.656474407164 950
+    .quad 0x03FE501D69DADD660
+    .quad 0x03FE505B1F9C43ED7  # 0.656945216966 951
+    .quad 0x03FE505B1F9C43ED7
+    .quad 0x03FE5098DCCE9FABA  # 0.657416248534 952
+    .quad 0x03FE5098DCCE9FABA
+    .quad 0x03FE50D6A173BC425  # 0.657887502077 953
+    .quad 0x03FE50D6A173BC425
+    .quad 0x03FE51146D8D65F98  # 0.658358977805 954
+    .quad 0x03FE51146D8D65F98
+    .quad 0x03FE5152411D69C03  # 0.658830675927 955
+    .quad 0x03FE5152411D69C03
+    .quad 0x03FE51AF0C774A2D0  # 0.659538640558 956
+    .quad 0x03FE51AF0C774A2D0
+    .quad 0x03FE51ECF2B713F8A  # 0.660010895584 957
+    .quad 0x03FE51ECF2B713F8A
+    .quad 0x03FE522AE0738A3D8  # 0.660483373741 958
+    .quad 0x03FE522AE0738A3D8
+    .quad 0x03FE5268D5AE7CDCB  # 0.660956075239 959
+    .quad 0x03FE5268D5AE7CDCB
+    .quad 0x03FE52A6D269BC600  # 0.661429000289 960
+    .quad 0x03FE52A6D269BC600
+    .quad 0x03FE52E4D6A719F9B  # 0.661902149103 961
+    .quad 0x03FE52E4D6A719F9B
+    .quad 0x03FE5322E26867857  # 0.662375521893 962
+    .quad 0x03FE5322E26867857
+    .quad 0x03FE53800225BA6E2  # 0.663086001497 963
+    .quad 0x03FE53800225BA6E2
+    .quad 0x03FE53BE20B8DA502  # 0.663559935155 964
+    .quad 0x03FE53BE20B8DA502
+    .quad 0x03FE53FC46D64DDD1  # 0.664034093533 965
+    .quad 0x03FE53FC46D64DDD1
+    .quad 0x03FE543A747FE9ED6  # 0.664508476843 966
+    .quad 0x03FE543A747FE9ED6
+    .quad 0x03FE5478A9B78404C  # 0.664983085300 967
+    .quad 0x03FE5478A9B78404C
+    .quad 0x03FE54B6E67EF251C  # 0.665457919117 968
+    .quad 0x03FE54B6E67EF251C
+    .quad 0x03FE54F52AD80BAE9  # 0.665932978509 969
+    .quad 0x03FE54F52AD80BAE9
+    .quad 0x03FE553376C4A7A16  # 0.666408263689 970
+    .quad 0x03FE553376C4A7A16
+    .quad 0x03FE5571CA469E5C9  # 0.666883774872 971
+    .quad 0x03FE5571CA469E5C9
+    .quad 0x03FE55CF55C5A5437  # 0.667597465874 972
+    .quad 0x03FE55CF55C5A5437
+    .quad 0x03FE560DBC45153C7  # 0.668073543008 973
+    .quad 0x03FE560DBC45153C7
+    .quad 0x03FE564C2A6059FE7  # 0.668549846899 974
+    .quad 0x03FE564C2A6059FE7
+    .quad 0x03FE568AA0194EC6E  # 0.669026377763 975
+    .quad 0x03FE568AA0194EC6E
+    .quad 0x03FE56C91D71CF810  # 0.669503135817 976
+    .quad 0x03FE56C91D71CF810
+    .quad 0x03FE5707A26BB8C66  # 0.669980121278 977
+    .quad 0x03FE5707A26BB8C66
+    .quad 0x03FE57462F08E7DF5  # 0.670457334363 978
+    .quad 0x03FE57462F08E7DF5
+    .quad 0x03FE5784C34B3AC30  # 0.670934775289 979
+    .quad 0x03FE5784C34B3AC30
+    .quad 0x03FE57C35F3490183  # 0.671412444273 980
+    .quad 0x03FE57C35F3490183
+    .quad 0x03FE580202C6C7353  # 0.671890341535 981
+    .quad 0x03FE580202C6C7353
+    .quad 0x03FE5840AE03C0204  # 0.672368467291 982
+    .quad 0x03FE5840AE03C0204
+    .quad 0x03FE589EBD437CA31  # 0.673086084831 983
+    .quad 0x03FE589EBD437CA31
+    .quad 0x03FE58DD7BB392B30  # 0.673564782782 984
+    .quad 0x03FE58DD7BB392B30
+    .quad 0x03FE591C41D500163  # 0.674043709994 985
+    .quad 0x03FE591C41D500163
+    .quad 0x03FE595B0FA9A7EF1  # 0.674522866688 986
+    .quad 0x03FE595B0FA9A7EF1
+    .quad 0x03FE5999E5336E121  # 0.675002253082 987
+    .quad 0x03FE5999E5336E121
+    .quad 0x03FE59D8C2743705E  # 0.675481869398 988
+    .quad 0x03FE59D8C2743705E
+    .quad 0x03FE5A17A76DE803B  # 0.675961715857 989
+    .quad 0x03FE5A17A76DE803B
+    .quad 0x03FE5A56942266F7B  # 0.676441792678 990
+    .quad 0x03FE5A56942266F7B
+    .quad 0x03FE5A9588939A810  # 0.676922100084 991
+    .quad 0x03FE5A9588939A810
+    .quad 0x03FE5AD484C369F2D  # 0.677402638296 992
+    .quad 0x03FE5AD484C369F2D
+    .quad 0x03FE5B1388B3BD53E  # 0.677883407536 993
+    .quad 0x03FE5B1388B3BD53E
+    .quad 0x03FE5B5294667D5F7  # 0.678364408027 994
+    .quad 0x03FE5B5294667D5F7
+    .quad 0x03FE5B91A7DD93852  # 0.678845639990 995
+    .quad 0x03FE5B91A7DD93852
+    .quad 0x03FE5BD0C31AE9E9D  # 0.679327103649 996
+    .quad 0x03FE5BD0C31AE9E9D
+    .quad 0x03FE5C2F7A8ED5E5B  # 0.680049734055 997
+    .quad 0x03FE5C2F7A8ED5E5B
+    .quad 0x03FE5C6EA94431EF9  # 0.680531777930 998
+    .quad 0x03FE5C6EA94431EF9
+    .quad 0x03FE5CADDFC6874F5  # 0.681014054284 999
+    .quad 0x03FE5CADDFC6874F5
+    .quad 0x03FE5CED1E17C35C6  # 0.681496563340 1000
+    .quad 0x03FE5CED1E17C35C6
+    .quad 0x03FE5D2C6439D4252  # 0.681979305324 1001
+    .quad 0x03FE5D2C6439D4252
+    .quad 0x03FE5D6BB22EA86F6  # 0.682462280460 1002
+    .quad 0x03FE5D6BB22EA86F6
+    .quad 0x03FE5DAB07F82FB84  # 0.682945488974 1003
+    .quad 0x03FE5DAB07F82FB84
+    .quad 0x03FE5DEA65985A350  # 0.683428931091 1004
+    .quad 0x03FE5DEA65985A350
+    .quad 0x03FE5E29CB1118D32  # 0.683912607038 1005
+    .quad 0x03FE5E29CB1118D32
+    .quad 0x03FE5E6938645D390  # 0.684396517040 1006
+    .quad 0x03FE5E6938645D390
+    .quad 0x03FE5EA8AD9419C5B  # 0.684880661324 1007
+    .quad 0x03FE5EA8AD9419C5B
+    .quad 0x03FE5EE82AA241920  # 0.685365040118 1008
+    .quad 0x03FE5EE82AA241920
+    .quad 0x03FE5F27AF90C8705  # 0.685849653648 1009
+    .quad 0x03FE5F27AF90C8705
+    .quad 0x03FE5F673C61A2ED2  # 0.686334502142 1010
+    .quad 0x03FE5F673C61A2ED2
+    .quad 0x03FE5FA6D116C64F7  # 0.686819585829 1011
+    .quad 0x03FE5FA6D116C64F7
+    .quad 0x03FE5FE66DB228992  # 0.687304904936 1012
+    .quad 0x03FE5FE66DB228992
+    .quad 0x03FE60261235C0874  # 0.687790459692 1013
+    .quad 0x03FE60261235C0874
+    .quad 0x03FE6065BEA385926  # 0.688276250325 1014
+    .quad 0x03FE6065BEA385926
+    .quad 0x03FE60A572FD6FEF1  # 0.688762277066 1015
+    .quad 0x03FE60A572FD6FEF1
+    .quad 0x03FE60E52F45788E4  # 0.689248540144 1016
+    .quad 0x03FE60E52F45788E4
+    .quad 0x03FE6124F37D991D4  # 0.689735039789 1017
+    .quad 0x03FE6124F37D991D4
+    .quad 0x03FE6164BFA7CC06C  # 0.690221776231 1018
+    .quad 0x03FE6164BFA7CC06C
+    .quad 0x03FE61A493C60C729  # 0.690708749700 1019
+    .quad 0x03FE61A493C60C729
+    .quad 0x03FE61E46FDA56466  # 0.691195960429 1020
+    .quad 0x03FE61E46FDA56466
+    .quad 0x03FE622453E6A6263  # 0.691683408647 1021
+    .quad 0x03FE622453E6A6263
+    .quad 0x03FE62643FECF9743  # 0.692171094587 1022
+    .quad 0x03FE62643FECF9743
+    .quad 0x03FE62A433EF4E51A  # 0.692659018480 1023
+    .quad 0x03FE62A433EF4E51A
+
+
+
diff --git a/src/gas/vrdasin.S b/src/gas/vrdasin.S
new file mode 100644
index 0000000..a5fb8d4
--- /dev/null
+++ b/src/gas/vrdasin.S
@@ -0,0 +1,3073 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrdasin.s
+#
+# An array implementation of the sin libm function.
+#
+# Prototype:
+#
+#    void vrda_sin(int n, double *x, double *y);
+#
+#Computes Sine of x for an array of input values.
+#Places the results into the supplied y array.
+#Does not perform error checking.
+#Denormal inputs may produce unexpected results
+#Author: Harsha Jagasia
+#Email:  harsha.jagasia@amd.com
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.data
+.align 16
+.L__real_7fffffffffffffff: 	.quad 0x07fffffffffffffff	#Sign bit zero
+				.quad 0x07fffffffffffffff
+.L__real_3ff0000000000000: 	.quad 0x03ff0000000000000	# 1.0
+				.quad 0x03ff0000000000000
+.L__real_v2p__27:		.quad 0x03e40000000000000	# 2p-27
+				.quad 0x03e40000000000000
+.L__real_3fe0000000000000: 	.quad 0x03fe0000000000000	# 0.5
+				.quad 0x03fe0000000000000
+.L__real_3fc5555555555555: 	.quad 0x03fc5555555555555	# 0.166666666666
+				.quad 0x03fc5555555555555
+.L__real_3fe45f306dc9c883: 	.quad 0x03fe45f306dc9c883	# twobypi
+				.quad 0x03fe45f306dc9c883
+.L__real_3ff921fb54400000: 	.quad 0x03ff921fb54400000	# piby2_1
+				.quad 0x03ff921fb54400000
+.L__real_3dd0b4611a626331: 	.quad 0x03dd0b4611a626331	# piby2_1tail
+				.quad 0x03dd0b4611a626331
+.L__real_3dd0b4611a600000: 	.quad 0x03dd0b4611a600000	# piby2_2
+				.quad 0x03dd0b4611a600000
+.L__real_3ba3198a2e037073: 	.quad 0x03ba3198a2e037073	# piby2_2tail
+				.quad 0x03ba3198a2e037073
+.L__real_fffffffff8000000: 	.quad 0x0fffffffff8000000	# mask for stripping head and tail
+				.quad 0x0fffffffff8000000
+.L__real_8000000000000000:	.quad 0x08000000000000000	# -0  or signbit
+				.quad 0x08000000000000000
+.L__reald_one_one:		.quad 0x00000000100000001	#
+				.quad 0
+.L__reald_two_two:		.quad 0x00000000200000002	#
+				.quad 0
+.L__reald_one_zero:		.quad 0x00000000100000000	# sin_cos_filter
+				.quad 0
+.L__reald_zero_one:		.quad 0x00000000000000001	#
+				.quad 0
+.L__reald_two_zero:		.quad 0x00000000200000000	#
+				.quad 0
+.L__realq_one_one:		.quad 0x00000000000000001	#
+				.quad 0x00000000000000001	#
+.L__realq_two_two:		.quad 0x00000000000000002	#
+				.quad 0x00000000000000002	#
+.L__real_1_x_mask:		.quad 0x0ffffffffffffffff	#
+				.quad 0x03ff0000000000000	#
+.L__real_zero:			.quad 0x00000000000000000	#
+				.quad 0x00000000000000000	#
+.L__real_one:			.quad 0x00000000000000001	#
+				.quad 0x00000000000000001	#
+.Lcosarray:
+	.quad	0x03fa5555555555555		# 0.0416667		   	c1
+	.quad	0x03fa5555555555555
+	.quad	0x0bf56c16c16c16967		# -0.00138889	   		c2
+	.quad	0x0bf56c16c16c16967
+	.quad	0x03efa01a019f4ec90		# 2.48016e-005			c3
+	.quad	0x03efa01a019f4ec90
+	.quad	0x0be927e4fa17f65f6		# -2.75573e-007			c4
+	.quad	0x0be927e4fa17f65f6
+	.quad	0x03e21eeb69037ab78		# 2.08761e-009			c5
+	.quad	0x03e21eeb69037ab78
+	.quad	0x0bda907db46cc5e42		# -1.13826e-011	   		c6
+	.quad	0x0bda907db46cc5e42
+.Lsinarray:
+	.quad	0x0bfc5555555555555		# -0.166667	   		s1
+	.quad	0x0bfc5555555555555
+	.quad	0x03f81111111110bb3		# 0.00833333	   		s2
+	.quad	0x03f81111111110bb3
+	.quad	0x0bf2a01a019e83e5c		# -0.000198413			s3
+	.quad	0x0bf2a01a019e83e5c
+	.quad	0x03ec71de3796cde01		# 2.75573e-006			s4
+	.quad	0x03ec71de3796cde01
+	.quad	0x0be5ae600b42fdfa7		# -2.50511e-008			s5
+	.quad	0x0be5ae600b42fdfa7
+	.quad	0x03de5e0b2f9a43bb8		# 1.59181e-010	   		s6
+	.quad	0x03de5e0b2f9a43bb8
+.Lsincosarray:
+	.quad	0x0bfc5555555555555		# -0.166667	   		s1
+	.quad	0x03fa5555555555555		# 0.0416667		   	c1
+	.quad	0x03f81111111110bb3		# 0.00833333	   		s2
+	.quad	0x0bf56c16c16c16967
+	.quad	0x0bf2a01a019e83e5c		# -0.000198413			s3
+	.quad	0x03efa01a019f4ec90
+	.quad	0x03ec71de3796cde01		# 2.75573e-006			s4
+	.quad	0x0be927e4fa17f65f6
+	.quad	0x0be5ae600b42fdfa7		# -2.50511e-008			s5
+	.quad	0x03e21eeb69037ab78
+	.quad	0x03de5e0b2f9a43bb8		# 1.59181e-010	   		s6
+	.quad	0x0bda907db46cc5e42
+.Lcossinarray:
+	.quad	0x03fa5555555555555		# 0.0416667		   	c1
+	.quad	0x0bfc5555555555555		# -0.166667	   		s1
+	.quad	0x0bf56c16c16c16967
+	.quad	0x03f81111111110bb3		# 0.00833333	   		s2
+	.quad	0x03efa01a019f4ec90
+	.quad	0x0bf2a01a019e83e5c		# -0.000198413			s3
+	.quad	0x0be927e4fa17f65f6
+	.quad	0x03ec71de3796cde01		# 2.75573e-006			s4
+	.quad	0x03e21eeb69037ab78
+	.quad	0x0be5ae600b42fdfa7		# -2.50511e-008			s5
+	.quad	0x0bda907db46cc5e42
+	.quad	0x03de5e0b2f9a43bb8		# 1.59181e-010	   		s6
+
+.Levensin_oddcos_tbl:
+		.quad	.Lsinsin_sinsin_piby4		# 0
+		.quad	.Lsinsin_sincos_piby4		# 1
+		.quad	.Lsinsin_cossin_piby4		# 2
+		.quad	.Lsinsin_coscos_piby4		# 3
+
+		.quad	.Lsincos_sinsin_piby4		# 4
+		.quad	.Lsincos_sincos_piby4		# 5
+		.quad	.Lsincos_cossin_piby4		# 6
+		.quad	.Lsincos_coscos_piby4		# 7
+
+		.quad	.Lcossin_sinsin_piby4		# 8
+		.quad	.Lcossin_sincos_piby4		# 9
+		.quad	.Lcossin_cossin_piby4		# 10
+		.quad	.Lcossin_coscos_piby4		# 11
+
+		.quad	.Lcoscos_sinsin_piby4		# 12
+		.quad	.Lcoscos_sincos_piby4		# 13
+		.quad	.Lcoscos_cossin_piby4		# 14
+		.quad	.Lcoscos_coscos_piby4		# 15
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+        .weak vrda_sin_
+        .set vrda_sin_,__vrda_sin__
+        .weak vrda_sin__
+        .set vrda_sin__,__vrda_sin__
+
+    .text
+    .align 16
+    .p2align 4,,15
+
+#x/* a FORTRAN subroutine implementation of array sin
+#**     VRDA_SIN(N,X,Y)
+# C equivalent*/
+#void vrda_sin__(int * n, double *x, double *y)
+#{
+#       vrda_sin(*n,x,y);
+#}
+.globl __vrda_sin__
+    .type   __vrda_sin__,@function
+__vrda_sin__:
+    mov         (%rdi),%edi
+
+    .align 16
+    .p2align 4,,15
+
+# define local variable storage offsets
+.equ	p_temp,		0x00		# temporary for get/put bits operation
+.equ	p_temp1,	0x10		# temporary for get/put bits operation
+
+.equ	save_xmm6,	0x20		# temporary for get/put bits operation
+.equ	save_xmm7,	0x30		# temporary for get/put bits operation
+.equ	save_xmm8,	0x40		# temporary for get/put bits operation
+.equ	save_xmm9,	0x50		# temporary for get/put bits operation
+.equ	save_xmm10,	0x60		# temporary for get/put bits operation
+.equ	save_xmm11,	0x70		# temporary for get/put bits operation
+.equ	save_xmm12,	0x80		# temporary for get/put bits operation
+.equ	save_xmm13,	0x90		# temporary for get/put bits operation
+.equ	save_xmm14,	0x0A0		# temporary for get/put bits operation
+.equ	save_xmm15,	0x0B0		# temporary for get/put bits operation
+
+.equ	r,		0x0C0		# pointer to r for remainder_piby2
+.equ	rr,		0x0D0		# pointer to r for remainder_piby2
+.equ	region,		0x0E0		# pointer to r for remainder_piby2
+
+.equ	r1,		0x0F0		# pointer to r for remainder_piby2
+.equ	rr1,		0x0100		# pointer to r for remainder_piby2
+.equ	region1,	0x0110		# pointer to r for remainder_piby2
+
+.equ	p_temp2,	0x0120		# temporary for get/put bits operation
+.equ	p_temp3,	0x0130		# temporary for get/put bits operation
+
+.equ	p_temp4,	0x0140		# temporary for get/put bits operation
+.equ	p_temp5,	0x0150		# temporary for get/put bits operation
+
+.equ	p_original,	0x0160		# original x
+.equ	p_mask,		0x0170		# original x
+.equ	p_sign,		0x0180		# original x
+
+.equ	p_original1,	0x0190		# original x
+.equ	p_mask1,	0x01A0		# original x
+.equ	p_sign1,	0x01B0		# original x
+
+.equ	save_r12,	0x01C0		# temporary for get/put bits operation
+.equ	save_r13,	0x01D0		# temporary for get/put bits operation
+
+.equ	save_xa,	0x01E0		#qword
+.equ	save_ya,	0x01F0		#qword
+
+.equ	save_nv,	0x0200		#qword
+.equ	p_iter,		0x0210		# qword	storage for number of loop iterations
+
+
+.globl vrda_sin
+    .type   vrda_sin,@function
+vrda_sin:
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# parameters are passed in by Linux as:
+# rcx - int n
+# rdx - double *x
+# r8  - double *y
+
+	sub	$0x228,%rsp
+	mov	%r12,save_r12(%rsp)	# save r12
+	mov	%r13,save_r13(%rsp)	# save r13
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#START PROCESS INPUT
+
+# save the arguments
+	mov		%rsi,	save_xa(%rsp)	# save x_array pointer
+	mov		%rdx,	save_ya(%rsp)	# save y_array pointer
+#ifdef INTEGER64
+        mov             %rdi,%rax
+#else
+        mov             %edi,%eax
+        mov             %rax,%rdi
+#endif
+	mov		%rdi,save_nv(%rsp)	# save number of values
+
+# see if too few values to call the main loop
+	shr		$2,%rax				# get number of iterations
+	jz		.L__vrda_cleanup			# jump if only single calls
+
+# prepare the iteration counts
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	shl		$2,%rax
+	sub		%rax,%rdi		# compute number of extra single calls
+	mov		%rdi,save_nv(%rsp)	# save number of left over values
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#START LOOP
+.align 16
+.L__vrda_top:
+
+# build the input _m128d
+	movapd	.L__real_7fffffffffffffff(%rip),%xmm2
+
+	mov	save_xa(%rsp),%rsi		# get x_array pointer
+	movlpd	(%rsi),%xmm0
+	movhpd	8(%rsi),%xmm0
+	mov	(%rsi),%rax
+	mov	8(%rsi),%rcx
+	movdqa	%xmm0,%xmm6
+
+	prefetch	64(%rsi)
+	add		$32,%rsi
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+
+	movlpd	-16(%rsi), %xmm1
+	movhpd	-8(%rsi), %xmm1
+	mov	-16(%rsi), %r8
+	mov	-8(%rsi), %r9
+	movdqa	%xmm1,%xmm7
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#STARTMAIN
+
+andpd 	%xmm2,%xmm0				#Unsign
+andpd 	%xmm2,%xmm1				#Unsign
+
+and	.L__real_7fffffffffffffff(%rip), %rax
+and	.L__real_7fffffffffffffff(%rip), %rcx
+and	.L__real_7fffffffffffffff(%rip), %r8
+and	.L__real_7fffffffffffffff(%rip), %r9
+
+movdqa	%xmm0,%xmm12
+movdqa	%xmm1,%xmm13
+
+pcmpgtd		%xmm6,%xmm12
+pcmpgtd		%xmm7,%xmm13
+movdqa		%xmm12,%xmm6
+movdqa		%xmm13,%xmm7
+psrldq		$4,%xmm12
+psrldq		$4,%xmm13
+psrldq		$8,%xmm6
+psrldq		$8,%xmm7
+
+mov 	$0x3FE921FB54442D18,%rdx			#piby4	+
+mov	$0x411E848000000000,%r10			#5e5	+
+movapd	.L__real_3fe0000000000000(%rip),%xmm4		#0.5 for later use	+
+
+por	%xmm6,%xmm12
+por	%xmm7,%xmm13
+movd	%xmm12,%r12				#Move Sign to gpr **
+movd	%xmm13,%r13				#Move Sign to gpr **
+
+movapd	%xmm0,%xmm2				#x0
+movapd	%xmm1,%xmm3				#x1
+movapd	%xmm0,%xmm6				#x0
+movapd	%xmm1,%xmm7				#x1
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm2 = x, xmm4 =0.5/t, xmm6 =x
+# xmm3 = x, xmm5 =0.5/t, xmm7 =x
+.align 16
+.Leither_or_both_arg_gt_than_piby4:
+	cmp	%r10,%rax
+	jae	.Lfirst_or_next3_arg_gt_5e5
+
+	cmp	%r10,%rcx
+	jae	.Lsecond_or_next2_arg_gt_5e5
+
+	cmp	%r10,%r8
+	jae	.Lthird_or_fourth_arg_gt_5e5
+
+	cmp	%r10,%r9
+	jae	.Lfourth_arg_gt_5e5
+
+
+#      /* Find out what multiple of piby2 */
+#        npi2  = (int)(x * twobypi + 0.5);
+	movapd	.L__real_3fe45f306dc9c883(%rip),%xmm0
+	mulpd	%xmm0,%xmm2						# * twobypi
+	mulpd	%xmm0,%xmm3						# * twobypi
+
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	addpd	%xmm4,%xmm3						# +0.5, npi2
+
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm0		# piby2_1
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm1		# piby2_1
+
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	cvttpd2dq	%xmm3,%xmm5					# convert packed double to packed integers
+
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm9		# piby2_2
+
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+	cvtdq2pd	%xmm5,%xmm3					# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+
+	movd	%xmm4,%r8						# Region
+	movd	%xmm5,%r9						# Region
+
+	mov 	.L__reald_one_zero(%rip),%rdx			#compare value for cossin path
+	mov	%r8,%r10
+	mov	%r9,%r11
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm0						# npi2 * piby2_1;
+       mulpd	%xmm3,%xmm1						# npi2 * piby2_1;
+
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+       mulpd	%xmm3,%xmm9						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm0,%xmm6						# rhead  = x - npi2 * piby2_1;
+       subpd	%xmm1,%xmm7						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm0						# t
+       movapd	%xmm7,%xmm1						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm0						# rhead
+       subpd	%xmm9,%xmm1						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm3		# npi2 * piby2_2tail
+
+       subpd	%xmm0,%xmm6						# t-rhead
+       subpd	%xmm1,%xmm7						# t-rhead
+
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       subpd	%xmm7,%xmm9						# - ((t - rhead) - rtail)
+
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       addpd	%xmm3,%xmm9						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm4  = npi2 (int), xmm0 =rhead, xmm8 =rtail
+# xmm5  = npi2 (int), xmm1 =rhead, xmm9 =rtail
+
+	and	.L__reald_one_one(%rip),%r8			#odd/even region for cos/sin
+	and	.L__reald_one_one(%rip),%r9			#odd/even region for cos/sin
+
+	shr	$1,%r10						#~AB+A~B, A is sign and B is upper bit of region
+	shr	$1,%r11						#~AB+A~B, A is sign and B is upper bit of region
+
+	mov	%r10,%rax
+	mov	%r11,%rcx
+
+	not 	%r12						#ADDED TO CHANGE THE LOGIC
+	not 	%r13						#ADDED TO CHANGE THE LOGIC
+	and	%r12,%r10
+	and	%r13,%r11
+
+	not	%rax
+	not	%rcx
+	not	%r12
+	not	%r13
+	and	%r12,%rax
+	and	%r13,%rcx
+
+	or	%rax,%r10
+	or	%rcx,%r11
+	and	.L__reald_one_one(%rip),%r10				#(~AB+A~B)&1
+	and	.L__reald_one_one(%rip),%r11				#(~AB+A~B)&1
+
+	mov	%r10,%r12
+	mov	%r11,%r13
+
+	and	%rdx,%r12				#mask out the lower sign bit leaving the upper sign bit
+	and	%rdx,%r13				#mask out the lower sign bit leaving the upper sign bit
+
+	shl	$63,%r10				#shift lower sign bit left by 63 bits
+	shl	$63,%r11				#shift lower sign bit left by 63 bits
+	shl	$31,%r12				#shift upper sign bit left by 31 bits
+	shl	$31,%r13				#shift upper sign bit left by 31 bits
+
+	mov 	 %r10,p_sign(%rsp)		#write out lower sign bit
+	mov 	 %r12,p_sign+8(%rsp)		#write out upper sign bit
+	mov 	 %r11,p_sign1(%rsp)		#write out lower sign bit
+	mov 	 %r13,p_sign1+8(%rsp)		#write out upper sign bit
+
+# GET_BITS_DP64(rhead-rtail, uy);			   		; originally only rhead
+# xmm4  = Sign, xmm0 =rhead, xmm8 =rtail
+# xmm5  = Sign, xmm1 =rhead, xmm9 =rtail
+	movapd	%xmm0,%xmm6						# rhead
+	movapd	%xmm1,%xmm7						# rhead
+
+	subpd	%xmm8,%xmm0						# r = rhead - rtail
+	subpd	%xmm9,%xmm1						# r = rhead - rtail
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm4  = Sign, xmm0 = r, xmm6 =rhead, xmm8 =rtail
+# xmm5  = Sign, xmm1 = r, xmm7 =rhead, xmm9 =rtail
+
+	subpd	%xmm0,%xmm6				#rr=rhead-r
+	subpd	%xmm1,%xmm7				#rr=rhead-r
+
+	mov	%r8,%rax
+	mov	%r9,%rcx
+
+	movapd	%xmm0,%xmm2				# move r for r2
+	movapd	%xmm1,%xmm3				# move r for r2
+
+	mulpd	%xmm0,%xmm2				# r2
+	mulpd	%xmm1,%xmm3				# r2
+
+	subpd	%xmm8,%xmm6				#rr=(rhead-r) -rtail
+	subpd	%xmm9,%xmm7				#rr=(rhead-r) -rtail
+
+
+	and	.L__reald_zero_one(%rip),%rax
+	and	.L__reald_zero_one(%rip),%rcx
+	shr	$31,%r8
+	shr	$31,%r9
+	or	%r8,%rax
+	or	%r9,%rcx
+	shl	$2,%rcx
+	or	%rcx,%rax
+
+#DEBUG
+#	jmp	.Lfinal_check
+#DEBUG
+
+	leaq	 .Levensin_oddcos_tbl(%rip),%rsi
+	jmp	 *(%rsi,%rax,8)				#Jmp table for cos/sin calculation based on even/odd region
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lfirst_or_next3_arg_gt_5e5:
+# %rcx,,%rax r8, r9
+
+	cmp	%r10,%rcx				#is upper arg >= 5e5
+	jae	.Lboth_arg_gt_5e5
+
+.Llower_arg_gt_5e5:
+# Upper Arg is < 5e5, Lower arg is >= 5e5
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+# Be sure not to use %xmm3,%xmm1 and xmm7
+# Use %xmm8,,%xmm5 xmm10, xmm12
+#	    %xmm11,,%xmm9 xmm13
+
+
+	movlpd	 %xmm0,r(%rsp)			#Save lower fp arg for remainder_piby2 call
+	movhlps	%xmm0,%xmm0			#Needed since we want to work on upper arg
+	movhlps	%xmm2,%xmm2
+	movhlps	%xmm6,%xmm6
+
+# Work on Upper arg
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm4,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm8		# xmm8 = piby2_1
+	cvttsd2si	%xmm2,%ecx				# ecx = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm10		# xmm10 = piby2_2
+	cvtsi2sd	%ecx,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm8					# npi2 * piby2_1
+	subsd	%xmm8,%xmm6					# xmm6 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm12		# xmm12 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm6,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm10					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm10,%xmm6					# xmm6 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm12     					# npi2 * piby2_2tail
+       subsd	%xmm6,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm10					# (rtail-(t-rhead))
+       addsd	%xmm12,%xmm10					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %ecx,region+4(%rsp)			# store upper region
+       movsd	%xmm6,%xmm0
+       subsd	%xmm10,%xmm0					# xmm0 = r=(rhead-rtail)
+       subsd	%xmm0,%xmm6					# rr=rhead-r
+       subsd	%xmm10,%xmm6					# xmm6 = rr=((rhead-r) -rtail)
+       movlpd	 %xmm0,r+8(%rsp)			# store upper r
+       movlpd	 %xmm6,rr+8(%rsp)			# store upper rr
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#Note that volatiles will be trashed by the call
+#We will construct r, rr, region and sign
+
+# Work on Lower arg
+	mov		$0x07ff0000000000000,%r11			# is lower arg nan/inf
+	mov		%r11,%r10
+	and		%rax,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_sin_lower_naninf
+
+
+	mov	  %r8,p_temp(%rsp)
+	mov	  %r9,p_temp2(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region(%rsp),%rdx			# lower arg is **NOT** nan/inf
+	lea	 rr(%rsp),%rsi
+	lea	 r(%rsp),%rdi
+	movlpd	 r(%rsp),%xmm0				#Restore lower fp arg for remainder_piby2 call
+        call	__amd_remainder_piby2@PLT
+
+	mov	 p_temp(%rsp),%r8
+	mov	 p_temp2(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+	jmp 	0f
+
+.L__vrd4_sin_lower_naninf:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rax
+	mov	 %rax,r(%rsp)				# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr(%rsp)				# rr = 0
+	mov	 %r10d,region(%rsp)			# region =0
+
+.align 16
+0:
+	jmp .Lcheck_next2_args
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lboth_arg_gt_5e5:
+#Upper Arg is >= 5e5, Lower arg is >= 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+
+	movhpd		%xmm0,r+8(%rsp)					#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r11			#is lower arg nan/inf
+	mov		%r11,%r10
+	and		%rax,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_sin_lower_naninf_of_both_gt_5e5
+
+	mov	  %rcx,p_temp(%rsp)			#Save upper arg
+	mov	  %r8,p_temp2(%rsp)
+	mov	  %r9,p_temp4(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	 rr(%rsp),%rsi
+	lea	 r(%rsp),%rdi
+        call	__amd_remainder_piby2@PLT
+
+	mov	 p_temp2(%rsp),%r8
+	mov	 p_temp4(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+
+	mov	 p_temp(%rsp),%rcx			#Restore upper arg
+	jmp 	0f
+
+.L__vrd4_sin_lower_naninf_of_both_gt_5e5:				#lower arg is nan/inf
+#	mov	p_original(r%sp),%rax
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rax
+	mov	%rax,r(%rsp)				#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	%r10,rr(%rsp)				#rr = 0
+	mov	%r10d,region(%rsp)			#region = 0
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r11			#is upper arg nan/inf
+	mov		%r11,%r10
+	and		%rcx,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_sin_upper_naninf_of_both_gt_5e5
+
+
+	mov	  %r8,p_temp2(%rsp)
+	mov	  %r9,p_temp4(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region+4(%rsp),%rdx			#upper arg is **NOT** nan/inf
+	lea	 rr+8(%rsp),%rsi
+	lea	 r+8(%rsp),%rdi
+	movlpd	 r+8(%rsp),%xmm0			#Restore upper fp arg for remainder_piby2 call
+        call	__amd_remainder_piby2@PLT
+
+	mov	 p_temp2(%rsp),%r8
+	mov	 p_temp4(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+
+	jmp 	0f
+
+.L__vrd4_sin_upper_naninf_of_both_gt_5e5:
+#	mov	p_original+8(%rsp),%rcx				;upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rcx
+	mov	%rcx,r+8(%rsp)				#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	%r10,rr+8(%rsp)			#rr = 0
+	mov	%r10d,region+4(%rsp)			#region = 0
+
+.align 16
+0:
+	jmp .Lcheck_next2_args
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lsecond_or_next2_arg_gt_5e5:
+
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+# Do not use %xmm3,,%xmm1 xmm7
+# Restore xmm4 and %xmm3,,%xmm1 xmm7
+# Can use %xmm10,,%xmm8 xmm12
+#   %xmm9,,%xmm5 xmm11, xmm13
+
+	movhpd	 %xmm0,r+8(%rsp)	#Save upper fp arg for remainder_piby2 call
+#	movlhps	%xmm0,%xmm0			;Not needed since we want to work on lower arg, but done just to be safe and avoide exceptions due to nan/inf and to mirror the lower_arg_gt_5e5 case
+#	movlhps	%xmm2,%xmm2
+#	movlhps	%xmm6,%xmm6
+
+# Work on Lower arg
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm4,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm8		# xmm3 = piby2_1
+	cvttsd2si	%xmm2,%eax				# ecx = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm10		# xmm1 = piby2_2
+	cvtsi2sd	%eax,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm8					# npi2 * piby2_1
+	subsd	%xmm8,%xmm6					# xmm6 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm12		# xmm7 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm6,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm10					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm10,%xmm6					# xmm6 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm12     					# npi2 * piby2_2tail
+       subsd	%xmm6,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm10					# (rtail-(t-rhead))
+       addsd	%xmm12,%xmm10					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %eax,region(%rsp)			# store upper region
+       movsd	%xmm6,%xmm0
+       subsd	%xmm10,%xmm0					# xmm0 = r=(rhead-rtail)
+       subsd	%xmm0,%xmm6					# rr=rhead-r
+       subsd	%xmm10,%xmm6					# xmm6 = rr=((rhead-r) -rtail)
+       movlpd	 %xmm0,r(%rsp)				# store upper r
+       movlpd	 %xmm6,rr(%rsp)				# store upper rr
+
+#Work on Upper arg
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+	mov		$0x07ff0000000000000,%r11			# is upper arg nan/inf
+	mov		%r11,%r10
+	and		%rcx,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_sin_upper_naninf
+
+
+	mov	 %r8,p_temp(%rsp)
+	mov	 %r9,p_temp2(%rsp)
+	movapd	 %xmm1,p_temp1(%rsp)
+	movapd	 %xmm3,p_temp3(%rsp)
+	movapd	 %xmm7,p_temp5(%rsp)
+
+	lea	 region+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 rr+8(%rsp),%rsi
+	lea	 r+8(%rsp),%rdi
+	movlpd	 r+8(%rsp),%xmm0	#Restore upper fp arg for remainder_piby2 call
+        call	__amd_remainder_piby2@PLT
+
+	mov	p_temp(%rsp),%r8
+	mov	p_temp2(%rsp),%r9
+	movapd	p_temp1(%rsp),%xmm1
+	movapd	p_temp3(%rsp),%xmm3
+	movapd	p_temp5(%rsp),%xmm7
+	jmp 	0f
+
+.L__vrd4_sin_upper_naninf:
+#	mov	p_original+8(%rsp),%rcx		; upper arg is nan/inf
+#	mov	r+8(%rsp),%rcx			; upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rcx
+	mov	 %rcx,r+8(%rsp)				# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr+8(%rsp)			# rr = 0
+	mov	 %r10d,region+4(%rsp)			# region =0
+
+.align 16
+0:
+
+	jmp 	.Lcheck_next2_args
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcheck_next2_args:
+
+	mov	$0x411E848000000000,%r10			#5e5	+
+
+	cmp	%r10,%r8
+	jae	.Lfirst_second_done_third_or_fourth_arg_gt_5e5
+
+	cmp	%r10,%r9
+	jae	.Lfirst_second_done_fourth_arg_gt_5e5
+
+
+
+# Work on next two args, both < 5e5
+# %xmm3,,%xmm1 xmm5 = x, xmm4 = 0.5
+
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4			#Restore 0.5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm3						# * twobypi
+	addpd	%xmm4,%xmm3						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm1		# piby2_1
+	cvttpd2dq	%xmm3,%xmm5					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm9		# piby2_2
+	cvtdq2pd	%xmm5,%xmm3					# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+       movq	 %xmm5,region1(%rsp)						# Region
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm3,%xmm1						# npi2 * piby2_1;
+
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm3,%xmm9						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm1,%xmm7						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm7,%xmm1						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm9,%xmm1						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm3		# npi2 * piby2_2tail
+
+       subpd	%xmm1,%xmm7						# t-rhead
+       subpd	%xmm7,%xmm9						# - ((t - rhead) - rtail)
+       addpd	%xmm3,%xmm9						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+       movapd	%xmm1,%xmm7						# rhead
+       subpd	%xmm9,%xmm1						# r = rhead - rtail
+       movapd	 %xmm1,r1(%rsp)
+
+       subpd	%xmm1,%xmm7						# rr=rhead-r
+       subpd	%xmm9,%xmm7						# rr=(rhead-r) -rtail
+       movapd	 %xmm7,rr1(%rsp)
+
+	jmp	.L__vrd4_sin_reconstruct
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lthird_or_fourth_arg_gt_5e5:
+#first two args are < 5e5, third arg >= 5e5, fourth arg >= 5e5 or < 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+# Do not use %xmm3,,%xmm1 xmm7
+# Can use 	%xmm11,,%xmm9 xmm13
+# 	%xmm8,,%xmm5 xmm10, xmm12
+# Restore xmm4
+
+# Work on first two args, both < 5e5
+
+
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm2						# * twobypi
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm0		# piby2_1
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movq	 %xmm4,region(%rsp)				# Region
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm0						# npi2 * piby2_1;
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm0,%xmm6						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm0						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm0						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+
+       subpd	%xmm0,%xmm6						# t-rhead
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+       movapd	%xmm0,%xmm6						# rhead
+       subpd	%xmm8,%xmm0						# r = rhead - rtail
+       movapd	 %xmm0,r(%rsp)
+
+       subpd	%xmm0,%xmm6						# rr=rhead-r
+       subpd	%xmm8,%xmm6						# rr=(rhead-r) -rtail
+       movapd	 %xmm6,rr(%rsp)
+
+
+# Work on next two args, third arg >= 5e5, fourth arg >= 5e5 or < 5e5
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lfirst_second_done_third_or_fourth_arg_gt_5e5:
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+
+	mov	$0x411E848000000000,%r10			#5e5	+
+	cmp	%r10,%r9
+	jae	.Lboth_arg_gt_5e5_higher
+
+
+# Upper Arg is <5e5, Lower arg is >= 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+	movlpd	 %xmm1,r1(%rsp)		#Save lower fp arg for remainder_piby2 call
+	movhlps	%xmm1,%xmm1			#Needed since we want to work on upper arg
+	movhlps	%xmm3,%xmm3
+	movhlps	%xmm7,%xmm7
+
+
+# Work on Upper arg
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4		# Restore 0.5
+
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm3		# x*twobypi
+	addsd	%xmm4,%xmm3					# xmm3 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm2		# xmm2 = piby2_1
+	cvttsd2si	%xmm3,%r9d				# r9d = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm0		# xmm0 = piby2_2
+	cvtsi2sd	%r9d,%xmm3				# xmm3 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm3,%xmm2					# npi2 * piby2_1
+	subsd	%xmm2,%xmm7					# xmm7 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm7,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm3,%xmm0					# xmm0 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm0,%xmm7					# xmm7 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm3,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm7,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm0					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm0					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %r9d,region1+4(%rsp)			# store upper region
+       movsd	%xmm7,%xmm1
+       subsd	%xmm0,%xmm1					# xmm1 = r=(rhead-rtail)
+       subsd	%xmm1,%xmm7					# rr=rhead-r
+       subsd	%xmm0,%xmm7					# xmm7 = rr=((rhead-r) -rtail)
+       movlpd	 %xmm1,r1+8(%rsp)			# store upper r
+       movlpd	 %xmm7,rr1+8(%rsp)			# store upper rr
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+
+# Work on Lower arg
+	mov		$0x07ff0000000000000,%r11			# is lower arg nan/inf
+	mov		%r11,%r10
+	and		%r8,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_sin_lower_naninf_higher
+
+	lea	 region1(%rsp),%rdx			# lower arg is **NOT** nan/inf
+	lea	 rr1(%rsp),%rsi
+	lea	 r1(%rsp),%rdi
+	movlpd	 r1(%rsp),%xmm0				#Restore lower fp arg for remainder_piby2 call
+        call	__amd_remainder_piby2@PLT
+	jmp 	0f
+
+.L__vrd4_sin_lower_naninf_higher:
+#	mov	p_original1(%rsp),%r8			; upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r8
+	mov	 %r8,r1(%rsp)				# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr1(%rsp)				# rr = 0
+	mov	 %r10d,region1(%rsp)			# region =0
+
+.align 16
+0:
+	jmp 	.L__vrd4_sin_reconstruct
+
+.align 16
+.Lboth_arg_gt_5e5_higher:
+# Upper Arg is >= 5e5, Lower arg is >= 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+
+	movhpd 		%xmm1,r1+8(%rsp)		#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r11			#is lower arg nan/inf
+	mov		%r11,%r10
+	and		%r8,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_sin_lower_naninf_of_both_gt_5e5_higher
+
+	mov	 %r9,p_temp1(%rsp)			#Save upper arg
+	lea	 region1(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	 rr1(%rsp),%rsi
+	lea	 r1(%rsp),%rdi
+	movsd	 %xmm1,%xmm0
+        call	__amd_remainder_piby2@PLT
+	mov	 p_temp1(%rsp),%r9			#Restore upper arg
+	jmp 	0f
+
+.L__vrd4_sin_lower_naninf_of_both_gt_5e5_higher:				#lower arg is nan/inf
+#	mov	p_original1(%rsp),%r8
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r8
+	mov	%r8,r1(%rsp)				#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	%r10,rr1(%rsp)				#rr = 0
+	mov	%r10d,region1(%rsp)			#region = 0
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r11			#is upper arg nan/inf
+	mov		%r11,%r10
+	and		%r9,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_sin_upper_naninf_of_both_gt_5e5_higher
+
+	lea	 region1+4(%rsp),%rdx			#upper arg is **NOT** nan/inf
+	lea	 rr1+8(%rsp),%rsi
+	lea	 r1+8(%rsp),%rdi
+	movlpd	 r1+8(%rsp),%xmm0			#Restore upper fp arg for remainder_piby2 call
+        call	__amd_remainder_piby2@PLT
+	jmp 	0f
+
+.L__vrd4_sin_upper_naninf_of_both_gt_5e5_higher:
+#	mov	p_original1+8(%rsp),%r9			;upper arg is nan/inf
+#	movd	%xmm6,%r9				;upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r9
+	mov	%r9,r1+8(%rsp)				#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	%r10,rr1+8(%rsp)			#rr = 0
+	mov	%r10d,region1+4(%rsp)			#region = 0
+
+.align 16
+0:
+	jmp .L__vrd4_sin_reconstruct
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lfourth_arg_gt_5e5:
+#first two args are < 5e5, third arg < 5e5, fourth arg >= 5e5
+#%rcx,,%rax r8, r9
+#%xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+
+# Work on first two args, both < 5e5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm2						# * twobypi
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm0		# piby2_1
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movq	 %xmm4,region(%rsp)						# Region
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm0						# npi2 * piby2_1;
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm0,%xmm6						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm0						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm0						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+
+       subpd	%xmm0,%xmm6						# t-rhead
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+       movapd	%xmm0,%xmm6						# rhead
+       subpd	%xmm8,%xmm0						# r = rhead - rtail
+       movapd	 %xmm0,r(%rsp)
+
+       subpd	%xmm0,%xmm6						# rr=rhead-r
+       subpd	%xmm8,%xmm6						# rr=(rhead-r) -rtail
+       movapd	 %xmm6,rr(%rsp)
+
+
+# Work on next two args, third arg < 5e5, fourth arg >= 5e5
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lfirst_second_done_fourth_arg_gt_5e5:
+
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+	movhpd	 %xmm1,r1+8(%rsp)	#Save upper fp arg for remainder_piby2 call
+#	movlhps	%xmm1,%xmm1			;Not needed since we want to work on lower arg, but done just to be safe and avoide exceptions due to nan/inf and to mirror the lower_arg_gt_5e5 case
+#	movlhps	%xmm3,%xmm3
+#	movlhps	%xmm7,%xmm7
+
+
+# Work on Lower arg
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4		# Restore 0.5
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm3		# x*twobypi
+	addsd	%xmm4,%xmm3					# xmm3 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm2		# xmm2 = piby2_1
+	cvttsd2si	%xmm3,%r8d				# r8d = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm0		# xmm0 = piby2_2
+	cvtsi2sd	%r8d,%xmm3				# xmm3 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm3,%xmm2					# npi2 * piby2_1
+	subsd	%xmm2,%xmm7					# xmm7 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm7,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm3,%xmm0					# xmm0 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm0,%xmm7					# xmm7 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm3,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm7,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm0					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm0					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %r8d,region1(%rsp)			# store lower region
+       movsd	%xmm7,%xmm1
+       subsd	%xmm0,%xmm1					# xmm0 = r=(rhead-rtail)
+       subsd	%xmm1,%xmm7					# rr=rhead-r
+       subsd	%xmm0,%xmm7					# xmm6 = rr=((rhead-r) -rtail)
+
+       movlpd	 %xmm1,r1(%rsp)				# store upper r
+       movlpd	 %xmm7,rr1(%rsp)				# store upper rr
+
+#Work on Upper arg
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+	mov		$0x07ff0000000000000,%r11			# is upper arg nan/inf
+	mov		%r11,%r10
+	and		%r9,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_sin_upper_naninf_higher
+
+	lea	 region1+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 rr1+8(%rsp),%rsi
+	lea	 r1+8(%rsp),%rdi
+	movlpd	 r1+8(%rsp),%xmm0	#Restore upper fp arg for remainder_piby2 call
+        call	__amd_remainder_piby2@PLT
+	jmp 	0f
+
+.L__vrd4_sin_upper_naninf_higher:
+#	mov	p_original1+8(%rsp),%r9		; upper arg is nan/inf
+#	mov	r1+8(%rsp),%r9				; upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r9
+	mov	%r9,r1+8(%rsp)				# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	%r10,rr1+8(%rsp)			# rr = 0
+	mov	%r10d,region1+4(%rsp)			# region =0
+
+.align 16
+0:
+	jmp	.L__vrd4_sin_reconstruct
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrd4_sin_reconstruct:
+#Results
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	movapd	r(%rsp),%xmm0
+	movapd	r1(%rsp),%xmm1
+
+	movapd	rr(%rsp),%xmm6
+	movapd	rr1(%rsp),%xmm7
+
+	mov	region(%rsp),%r8
+	mov	region1(%rsp),%r9
+	mov 	.L__reald_one_zero(%rip),%rdx		#compare value for cossin path
+
+	mov 	%r8,%r10
+	mov 	%r9,%r11
+
+	and	.L__reald_one_one(%rip),%r8		#odd/even region for cos/sin
+	and	.L__reald_one_one(%rip),%r9		#odd/even region for cos/sin
+
+	shr	$1,%r10						#~AB+A~B, A is sign and B is upper bit of region
+	shr	$1,%r11						#~AB+A~B, A is sign and B is upper bit of region
+
+	mov	%r10,%rax
+	mov	%r11,%rcx
+
+	not 	%r12						#ADDED TO CHANGE THE LOGIC
+	not 	%r13						#ADDED TO CHANGE THE LOGIC
+	and	%r12,%r10
+	and	%r13,%r11
+
+	not	%rax
+	not	%rcx
+	not	%r12
+	not	%r13
+	and	%r12,%rax
+	and	%r13,%rcx
+
+	or	%rax,%r10
+	or	%rcx,%r11
+	and	.L__reald_one_one(%rip),%r10				#(~AB+A~B)&1
+	and	.L__reald_one_one(%rip),%r11				#(~AB+A~B)&1
+
+	mov	%r10,%r12
+	mov	%r11,%r13
+
+	and	%rdx,%r12				#mask out the lower sign bit leaving the upper sign bit
+	and	%rdx,%r13				#mask out the lower sign bit leaving the upper sign bit
+
+	shl	$63,%r10				#shift lower sign bit left by 63 bits
+	shl	$63,%r11				#shift lower sign bit left by 63 bits
+	shl	$31,%r12				#shift upper sign bit left by 31 bits
+	shl	$31,%r13				#shift upper sign bit left by 31 bits
+
+	mov 	 %r10,p_sign(%rsp)		#write out lower sign bit
+	mov 	 %r12,p_sign+8(%rsp)		#write out upper sign bit
+	mov 	 %r11,p_sign1(%rsp)		#write out lower sign bit
+	mov 	 %r13,p_sign1+8(%rsp)		#write out upper sign bit
+
+	mov	%r8,%rax
+	mov	%r9,%rcx
+
+	movapd	%xmm0,%xmm2
+	movapd	%xmm1,%xmm3
+
+	mulpd	%xmm0,%xmm2				# r2
+	mulpd	%xmm1,%xmm3				# r2
+
+	and	.L__reald_zero_one(%rip),%rax
+	and	.L__reald_zero_one(%rip),%rcx
+	shr	$31,%r8
+	shr	$31,%r9
+	or	%r8,%rax
+	or	%r9,%rcx
+	shl	$2,%rcx
+	or	%rcx,%rax
+
+	leaq	 .Levensin_oddcos_tbl(%rip),%rsi
+	jmp	 *(%rsi,%rax,8)	#Jmp table for cos/sin calculation based on even/odd region
+
+
+
+
+
+
+
+
+
+
+
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrd4_sin_cleanup:
+
+	movapd	p_sign(%rsp),	%xmm0
+	movapd	p_sign1(%rsp),	%xmm1
+	xorpd	%xmm4,		%xmm0				# (+) Sign
+	xorpd	%xmm5,		%xmm1				# (+) Sign
+
+.L__vrda_bottom1:
+# store the result _m128d
+	mov	save_ya(%rsp),%rdi				# get y_array pointer
+	movlpd	%xmm0,(%rdi)
+	movhpd	%xmm0,8(%rdi)
+
+.L__vrda_bottom2:
+	prefetch	64(%rdi)
+	add		$32,%rdi
+	mov		%rdi,save_ya(%rsp)			# save y_array pointer
+
+# store the result _m128d
+	movlpd	%xmm1, -16(%rdi)
+	movhpd	%xmm1, -8(%rdi)
+
+	mov	p_iter(%rsp),%rax		# get number of iterations
+	sub	$1,%rax
+	mov	%rax,p_iter(%rsp)		# save number of iterations
+	jnz	.L__vrda_top
+
+# see if we need to do any extras
+	mov	save_nv(%rsp),%rax		# get number of values
+	test	%rax,%rax
+	jnz	.L__vrda_cleanup
+
+.L__final_check:
+
+	mov	save_r12(%rsp),%r12	# restore r12
+	mov	save_r13(%rsp),%r13	# restore r13
+
+	add	$0x228,%rsp
+	ret
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# we jump here when we have an odd number of cos calls to make at the end
+# The number of values left is in save_nv
+
+.align	16
+.L__vrda_cleanup:
+        mov             save_nv(%rsp),%rax      # get number of values
+        test            %rax,%rax               # are there any values
+        jz              .L__final_check         # exit if not
+
+	mov		save_xa(%rsp),%rsi
+	mov		save_ya(%rsp),%rdi
+
+# fill in a m128d with zeroes and the extra values and then make a recursive call.
+	xorpd		 %xmm0,%xmm0
+	movlpd		 %xmm0,p_temp+8(%rsp)
+	movapd		 %xmm0,p_temp+16(%rsp)
+
+	mov		 (%rsi),%rcx			# we know there's at least one
+	mov	 	 %rcx,p_temp(%rsp)
+	cmp		 $2,%rax
+	jl		 .L__vrdacg
+
+	mov		 8(%rsi),%rcx			# do the second value
+	mov	 	 %rcx,p_temp+8(%rsp)
+	cmp		 $3,%rax
+	jl		 .L__vrdacg
+
+	mov		 16(%rsi),%rcx			# do the third value
+	mov	 	 %rcx,p_temp+16(%rsp)
+
+.L__vrdacg:
+	mov		 $4,%rdi			# parameter for N
+	lea		 p_temp(%rsp),%rsi		# &x parameter
+	lea		 p_temp2(%rsp),%rdx 		# &y parameter
+        call		vrda_sin@PLT			# call recursively to compute four values
+
+# now copy the results to the destination array
+	mov		 save_ya(%rsp),%rdi
+	mov		 save_nv(%rsp),%rax		# get number of values
+	mov	 	 p_temp2(%rsp),%rcx
+	mov		 %rcx, (%rdi)			# we know there's at least one
+	cmp		 $2,%rax
+	jl		 .L__vrdacgf
+
+	mov	 	 p_temp2+8(%rsp),%rcx
+	mov		 %rcx, 8(%rdi)			# do the second value
+	cmp		 $3,%rax
+	jl		 .L__vrdacgf
+
+	mov	 	 p_temp2+16(%rsp),%rcx
+	mov		 %rcx, 16(%rdi)			# do the third value
+
+.L__vrdacgf:
+	jmp		 .L__final_check
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;JUMP TABLE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcoscos_coscos_piby4:
+
+
+	movapd	%xmm2,%xmm10					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lcosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lcosarray+0x50(%rip),%xmm5			# c6
+
+	movapd	.Lcosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lcosarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# r
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm10		# -t=r-1.0	;trash r
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11		# -t=r-1.0	;trash r
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lcosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lcosarray+0x40(%rip),%xmm5			# c5+x2c6
+
+	addpd	.Lcosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lcosarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm10		# 1 + (-t)	;trash t
+	addpd   .L__real_3ff0000000000000(%rip),%xmm11		# 1 + (-t)	;trash t
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lcosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+
+	addpd	.Lcosarray(%rip),%xmm8				# c1 + x2(c2+x2C3)
+	addpd	.Lcosarray(%rip),%xmm9				# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm2,%xmm2					# x4 recalculate
+	mulpd	%xmm3,%xmm3					# x4 recalculate
+
+	movapd   p_temp2(%rsp),%xmm12			# r
+	movapd   p_temp3(%rsp),%xmm13			# r
+
+	mulpd	%xmm0,%xmm6					# x * xx
+	mulpd	%xmm1,%xmm7					# x * xx
+
+	subpd   %xmm12,%xmm10					# (1 + (-t)) - r
+	subpd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x4 * zc
+
+	subpd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx
+	subpd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	addpd   %xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addpd   %xmm11,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm12		# t relaculate, -t = r-1
+	subpd	.L__real_3ff0000000000000(%rip),%xmm13		# t relaculate, -t = r-1
+
+	subpd   %xmm12,%xmm4					# + t
+	subpd   %xmm13,%xmm5					# + t
+
+	jmp	.L__vrd4_sin_cleanup
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcossin_cossin_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	movapd	 %xmm6,p_temp(%rsp)		# Store rr
+	movapd	 %xmm7,p_temp1(%rsp)		# Store rr
+
+	movdqa	.Lsincosarray+0x50(%rip),%xmm4		# s6
+	movdqa	.Lsincosarray+0x50(%rip),%xmm5		# s6
+	movapd	.Lsincosarray+0x20(%rip),%xmm8		# s3
+	movapd	.Lsincosarray+0x20(%rip),%xmm9		# s3
+
+	movapd	%xmm2,%xmm10				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+
+	mulpd	%xmm2,%xmm4				# x2s6
+	mulpd	%xmm3,%xmm5				# x2s6
+	mulpd	%xmm2,%xmm8				# x2s3
+	mulpd	%xmm3,%xmm9				# x2s3
+
+	mulpd	%xmm2,%xmm10				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lsincosarray+0x40(%rip),%xmm4		# s5+x2s6
+	addpd	.Lsincosarray+0x40(%rip),%xmm5		# s5+x2s6
+	addpd	.Lsincosarray+0x10(%rip),%xmm8		# s2+x2s3
+	addpd	.Lsincosarray+0x10(%rip),%xmm9		# s2+x2s3
+
+	movapd	%xmm2,%xmm12				# move x2 for x6
+	movapd	%xmm3,%xmm13				# move x2 for x6
+
+	mulpd	%xmm2,%xmm4				# x2(s5+x2s6)
+	mulpd	%xmm3,%xmm5				# x2(s5+x2s6)
+	mulpd	%xmm2,%xmm8				# x2(s2+x2s3)
+	mulpd	%xmm3,%xmm9				# x2(s2+x2s3)
+
+	mulpd	%xmm10,%xmm12				# x6
+	mulpd	%xmm11,%xmm13				# x6
+
+	addpd	.Lsincosarray+0x30(%rip),%xmm4		# s4+x2(s5+x2s6)
+	addpd	.Lsincosarray+0x30(%rip),%xmm5		# s4+x2(s5+x2s6)
+	addpd	.Lsincosarray(%rip),%xmm8		# s1+x2(s2+x2s3)
+	addpd	.Lsincosarray(%rip),%xmm9		# s1+x2(s2+x2s3)
+
+	movhlps	%xmm10,%xmm10				# move high x4 for cos term
+	movhlps	%xmm11,%xmm11				# move high x4 for cos term
+	mulpd	%xmm12,%xmm4				# x6(s4+x2(s5+x2s6))
+	mulpd	%xmm13,%xmm5				# x6(s4+x2(s5+x2s6))
+
+	movsd	%xmm2,%xmm6				# move low x2 for x3 for sin term
+	movsd	%xmm3,%xmm7				# move low x2 for x3 for sin term
+	mulsd	%xmm0,%xmm6				# get low x3 for sin term
+	mulsd	%xmm1,%xmm7				# get low x3 for sin term
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for sin and cos terms
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for sin and cos terms
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm2,%xmm12				# move high r for cos
+	movhlps	%xmm3,%xmm13				# move high r for cos
+	movhlps	%xmm4,%xmm8				# xmm4 = sin , xmm8 = cos
+	movhlps	%xmm5,%xmm9				# xmm4 = sin , xmm8 = cos
+
+	mulsd	%xmm6,%xmm4				# sin *x3
+	mulsd	%xmm7,%xmm5				# sin *x3
+	mulsd	%xmm10,%xmm8				# cos *x4
+	mulsd	%xmm11,%xmm9				# cos *x4
+
+	mulsd	p_temp(%rsp),%xmm2		# 0.5 * x2 * xx for sin term
+	mulsd	p_temp1(%rsp),%xmm3		# 0.5 * x2 * xx for sin term
+	movsd	%xmm12,%xmm6				# Keep high r for cos term
+	movsd	%xmm13,%xmm7				# Keep high r for cos term
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12 	#-t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13 	#-t=r-1.0
+
+	subsd	%xmm2,%xmm4				# sin - 0.5 * x2 *xx
+	subsd	%xmm3,%xmm5				# sin - 0.5 * x2 *xx
+
+	movhlps	%xmm0,%xmm10				# move high x for x*xx for cos term
+	movhlps	%xmm1,%xmm11				# move high x for x*xx for cos term
+
+	mulsd	p_temp+8(%rsp),%xmm10		# x * xx
+	mulsd	p_temp1+8(%rsp),%xmm11		# x * xx
+
+	movsd	%xmm12,%xmm2				# move -t for cos term
+	movsd	%xmm13,%xmm3				# move -t for cos term
+
+	addsd	.L__real_3ff0000000000000(%rip),%xmm12 	#1+(-t)
+	addsd	.L__real_3ff0000000000000(%rip),%xmm13 	#1+(-t)
+	addsd	p_temp(%rsp),%xmm4			# sin+xx
+	addsd	p_temp1(%rsp),%xmm5			# sin+xx
+	subsd	%xmm6,%xmm12				# (1-t) - r
+	subsd	%xmm7,%xmm13				# (1-t) - r
+	subsd	%xmm10,%xmm12				# ((1 + (-t)) - r) - x*xx
+	subsd	%xmm11,%xmm13				# ((1 + (-t)) - r) - x*xx
+	addsd	%xmm0,%xmm4				# sin + x
+	addsd	%xmm1,%xmm5				# sin + x
+	addsd   %xmm12,%xmm8				# cos+((1-t)-r - x*xx)
+	addsd   %xmm13,%xmm9				# cos+((1-t)-r - x*xx)
+	subsd   %xmm2,%xmm8				# cos+t
+	subsd   %xmm3,%xmm9				# cos+t
+
+	movlhps	%xmm8,%xmm4
+	movlhps	%xmm9,%xmm5
+	jmp 	.L__vrd4_sin_cleanup
+
+.align 16
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lsincos_cossin_piby4:					# changed from sincos_sincos
+							# xmm1 is cossin and xmm0 is sincos
+
+	movapd	 %xmm6,p_temp(%rsp)		# Store rr
+	movapd	 %xmm7,p_temp1(%rsp)		# Store rr
+	movapd	 %xmm1,p_temp3(%rsp)		# Store r for the sincos term
+
+	movapd	.Lsincosarray+0x50(%rip),%xmm4		# s6
+	movapd	.Lcossinarray+0x50(%rip),%xmm5		# s6
+	movdqa	.Lsincosarray+0x20(%rip),%xmm8		# s3
+	movdqa	.Lcossinarray+0x20(%rip),%xmm9		# s3
+
+	movapd	%xmm2,%xmm10				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+
+	mulpd	%xmm2,%xmm4				# x2s6
+	mulpd	%xmm3,%xmm5				# x2s6
+	mulpd	%xmm2,%xmm8				# x2s3
+	mulpd	%xmm3,%xmm9				# x2s3
+
+	mulpd	%xmm2,%xmm10				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lsincosarray+0x40(%rip),%xmm4		# s5+x2s6
+	addpd	.Lcossinarray+0x40(%rip),%xmm5		# s5+x2s6
+	addpd	.Lsincosarray+0x10(%rip),%xmm8		# s2+x2s3
+	addpd	.Lcossinarray+0x10(%rip),%xmm9		# s2+x2s3
+
+	movapd	%xmm2,%xmm12				# move x2 for x6
+	movapd	%xmm3,%xmm13				# move x2 for x6
+
+	mulpd	%xmm2,%xmm4				# x2(s5+x2s6)
+	mulpd	%xmm3,%xmm5				# x2(s5+x2s6)
+	mulpd	%xmm2,%xmm8				# x2(s2+x2s3)
+	mulpd	%xmm3,%xmm9				# x2(s2+x2s3)
+
+	mulpd	%xmm10,%xmm12				# x6
+	mulpd	%xmm11,%xmm13				# x6
+
+	addpd	.Lsincosarray+0x30(%rip),%xmm4		# s4+x2(s5+x2s6)
+	addpd	.Lcossinarray+0x30(%rip),%xmm5		# s4+x2(s5+x2s6)
+	addpd	.Lsincosarray(%rip),%xmm8		# s1+x2(s2+x2s3)
+	addpd	.Lcossinarray(%rip),%xmm9		# s1+x2(s2+x2s3)
+
+	movhlps	%xmm10,%xmm10				# move high x4 for cos term
+
+	mulpd	%xmm12,%xmm4				# x6(s4+x2(s5+x2s6))
+	mulpd	%xmm13,%xmm5				# x6(s4+x2(s5+x2s6))
+
+	movsd	%xmm2,%xmm6				# move low x2 for x3 for sin term  (cossin)
+	movhlps	%xmm3,%xmm7				# move high x2 for x3 for sin term (sincos)
+
+	mulsd	%xmm0,%xmm6				# get low x3 for sin term
+	mulsd	p_temp3+8(%rsp),%xmm7			# get high x3 for sin term
+
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for sin and cos terms
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for sin and cos terms
+
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm2,%xmm12				# move high r for cos (cossin)
+	movhlps	%xmm3,%xmm13				# move high 0.5*x2 for sin term (sincos)
+
+	movhlps	%xmm4,%xmm8				# xmm8 = cos , xmm4 = sin	(cossin)
+	movhlps	%xmm5,%xmm9				# xmm9 = sin , xmm5 = cos	(sincos)
+
+	mulsd	%xmm6,%xmm4				# sin *x3
+	mulsd	%xmm11,%xmm5				# cos *x4
+	mulsd	%xmm10,%xmm8				# cos *x4
+	mulsd	%xmm7,%xmm9				# sin *x3
+
+	mulsd	p_temp(%rsp),%xmm2		# low  0.5 * x2 * xx for sin term (cossin)
+	mulsd	p_temp1+8(%rsp),%xmm13		# high 0.5 * x2 * xx for sin term (sincos)
+
+	movsd	%xmm12,%xmm6				# Keep high r for cos term
+	movsd	%xmm3,%xmm7				# Keep low r for cos term
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12 	# -t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm3 	# -t=r-1.0
+
+	subsd	%xmm2,%xmm4				# sin - 0.5 * x2 *xx	(cossin)
+	subsd	%xmm13,%xmm9				# sin - 0.5 * x2 *xx	(sincos)
+
+	movhlps	%xmm0,%xmm10				# move high x for x*xx for cos term (cossin)
+	movhlps	%xmm1,%xmm11				# move high x for x for sin term    (sincos)
+
+	mulsd	p_temp+8(%rsp),%xmm10		# x * xx
+	mulsd	p_temp1(%rsp),%xmm1		# x * xx
+
+	movsd	%xmm12,%xmm2				# move -t for cos term
+	movsd	%xmm3,%xmm13				# move -t for cos term
+
+	addsd	.L__real_3ff0000000000000(%rip),%xmm12	# 1+(-t)
+	addsd	.L__real_3ff0000000000000(%rip),%xmm3 	# 1+(-t)
+
+	addsd	p_temp(%rsp),%xmm4		# sin+xx	+
+	addsd	p_temp1+8(%rsp),%xmm9		# sin+xx	+
+
+	subsd	%xmm6,%xmm12				# (1-t) - r
+	subsd	%xmm7,%xmm3				# (1-t) - r
+
+	subsd	%xmm10,%xmm12				# ((1 + (-t)) - r) - x*xx
+	subsd	%xmm1,%xmm3				# ((1 + (-t)) - r) - x*xx
+
+	addsd	%xmm0,%xmm4				# sin + x	+
+	addsd	%xmm11,%xmm9				# sin + x	+
+
+	addsd   %xmm12,%xmm8				# cos+((1-t)-r - x*xx)
+	addsd   %xmm3,%xmm5				# cos+((1-t)-r - x*xx)
+
+	subsd   %xmm2,%xmm8				# cos+t
+	subsd   %xmm13,%xmm5				# cos+t
+
+	movlhps	%xmm8,%xmm4				# cossin
+	movlhps	%xmm9,%xmm5				# sincos
+
+	jmp	.L__vrd4_sin_cleanup
+
+.align 16
+.Lsincos_sincos_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	movapd	 %xmm6,p_temp(%rsp)		# Store rr
+	movapd	 %xmm7,p_temp1(%rsp)		# Store rr
+	movapd	 %xmm0,p_temp2(%rsp)		# Store r
+	movapd	 %xmm1,p_temp3(%rsp)		# Store r
+
+
+	movapd	.Lcossinarray+0x50(%rip),%xmm4		# s6
+	movapd	.Lcossinarray+0x50(%rip),%xmm5		# s6
+	movdqa	.Lcossinarray+0x20(%rip),%xmm8		# s3
+	movdqa	.Lcossinarray+0x20(%rip),%xmm9		# s3
+
+	movapd	%xmm2,%xmm10				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+
+	mulpd	%xmm2,%xmm4				# x2s6
+	mulpd	%xmm3,%xmm5				# x2s6
+	mulpd	%xmm2,%xmm8				# x2s3
+	mulpd	%xmm3,%xmm9				# x2s3
+
+	mulpd	%xmm2,%xmm10				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lcossinarray+0x40(%rip),%xmm4		# s5+x2s6
+	addpd	.Lcossinarray+0x40(%rip),%xmm5		# s5+x2s6
+	addpd	.Lcossinarray+0x10(%rip),%xmm8		# s2+x2s3
+	addpd	.Lcossinarray+0x10(%rip),%xmm9		# s2+x2s3
+
+	movapd	%xmm2,%xmm12				# move x2 for x6
+	movapd	%xmm3,%xmm13				# move x2 for x6
+
+	mulpd	%xmm2,%xmm4				# x2(s5+x2s6)
+	mulpd	%xmm3,%xmm5				# x2(s5+x2s6)
+	mulpd	%xmm2,%xmm8				# x2(s2+x2s3)
+	mulpd	%xmm3,%xmm9				# x2(s2+x2s3)
+
+	mulpd	%xmm10,%xmm12				# x6
+	mulpd	%xmm11,%xmm13				# x6
+
+	addpd	.Lcossinarray+0x30(%rip),%xmm4		# s4+x2(s5+x2s6)
+	addpd	.Lcossinarray+0x30(%rip),%xmm5		# s4+x2(s5+x2s6)
+	addpd	.Lcossinarray(%rip),%xmm8		# s1+x2(s2+x2s3)
+	addpd	.Lcossinarray(%rip),%xmm9		# s1+x2(s2+x2s3)
+
+	mulpd	%xmm12,%xmm4				# x6(s4+x2(s5+x2s6))
+	mulpd	%xmm13,%xmm5				# x6(s4+x2(s5+x2s6))
+
+	movhlps	%xmm2,%xmm6				# move low x2 for x3 for sin term
+	movhlps	%xmm3,%xmm7				# move low x2 for x3 for sin term
+	mulsd	p_temp2+8(%rsp),%xmm6		# get low x3 for sin term
+	mulsd	p_temp3+8(%rsp),%xmm7		# get low x3 for sin term
+
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for sin and cos terms
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for sin and cos terms
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm2,%xmm12				# move high 0.5*x2 for sin term
+	movhlps	%xmm3,%xmm13				# move high 0.5*x2 for sin term
+							# Reverse 12 and 2
+
+	movhlps	%xmm4,%xmm8				# xmm8 = sin , xmm4 = cos
+	movhlps	%xmm5,%xmm9				# xmm9 = sin , xmm5 = cos
+
+	mulsd	%xmm6,%xmm8				# sin *x3
+	mulsd	%xmm7,%xmm9				# sin *x3
+	mulsd	%xmm10,%xmm4				# cos *x4
+	mulsd	%xmm11,%xmm5				# cos *x4
+
+	mulsd	p_temp+8(%rsp),%xmm12		# 0.5 * x2 * xx for sin term
+	mulsd	p_temp1+8(%rsp),%xmm13		# 0.5 * x2 * xx for sin term
+	movsd	%xmm2,%xmm6				# Keep high r for cos term
+	movsd	%xmm3,%xmm7				# Keep high r for cos term
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm2 	#-t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm3 	#-t=r-1.0
+
+	subsd	%xmm12,%xmm8				# sin - 0.5 * x2 *xx
+	subsd	%xmm13,%xmm9				# sin - 0.5 * x2 *xx
+
+	movhlps	%xmm0,%xmm10				# move high x for x for sin term
+	movhlps	%xmm1,%xmm11				# move high x for x for sin term
+							# Reverse 10 and 0
+
+	mulsd	p_temp(%rsp),%xmm0		# x * xx
+	mulsd	p_temp1(%rsp),%xmm1		# x * xx
+
+	movsd	%xmm2,%xmm12				# move -t for cos term
+	movsd	%xmm3,%xmm13				# move -t for cos term
+
+	addsd	.L__real_3ff0000000000000(%rip),%xmm2 	# 1+(-t)
+	addsd	.L__real_3ff0000000000000(%rip),%xmm3 	# 1+(-t)
+	addsd	p_temp+8(%rsp),%xmm8			# sin+xx
+	addsd	p_temp1+8(%rsp),%xmm9			# sin+xx
+
+	subsd	%xmm6,%xmm2				# (1-t) - r
+	subsd	%xmm7,%xmm3				# (1-t) - r
+
+	subsd	%xmm0,%xmm2				# ((1 + (-t)) - r) - x*xx
+	subsd	%xmm1,%xmm3				# ((1 + (-t)) - r) - x*xx
+
+	addsd	%xmm10,%xmm8				# sin + x
+	addsd	%xmm11,%xmm9				# sin + x
+
+	addsd   %xmm2,%xmm4				# cos+((1-t)-r - x*xx)
+	addsd   %xmm3,%xmm5				# cos+((1-t)-r - x*xx)
+
+	subsd   %xmm12,%xmm4				# cos+t
+	subsd   %xmm13,%xmm5				# cos+t
+
+	movlhps	%xmm8,%xmm4
+	movlhps	%xmm9,%xmm5
+	jmp 	.L__vrd4_sin_cleanup
+
+.align 16
+.Lcossin_sincos_piby4:					# changed from sincos_sincos
+							# xmm1 is cossin and xmm0 is sincos
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+	movapd	 %xmm6,p_temp(%rsp)		# Store rr
+	movapd	 %xmm7,p_temp1(%rsp)		# Store rr
+	movapd	 %xmm0,p_temp2(%rsp)		# Store r
+
+
+	movapd	.Lcossinarray+0x50(%rip),%xmm4		# s6
+	movapd	.Lsincosarray+0x50(%rip),%xmm5		# s6
+	movdqa	.Lcossinarray+0x20(%rip),%xmm8		# s3
+	movdqa	.Lsincosarray+0x20(%rip),%xmm9		# s3
+
+	movapd	%xmm2,%xmm10				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+
+	mulpd	%xmm2,%xmm4				# x2s6
+	mulpd	%xmm3,%xmm5				# x2s6
+	mulpd	%xmm2,%xmm8				# x2s3
+	mulpd	%xmm3,%xmm9				# x2s3
+
+	mulpd	%xmm2,%xmm10				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lcossinarray+0x40(%rip),%xmm4		# s5+x2s6
+	addpd	.Lsincosarray+0x40(%rip),%xmm5		# s5+x2s6
+	addpd	.Lcossinarray+0x10(%rip),%xmm8		# s2+x2s3
+	addpd	.Lsincosarray+0x10(%rip),%xmm9		# s2+x2s3
+
+	movapd	%xmm2,%xmm12				# move x2 for x6
+	movapd	%xmm3,%xmm13				# move x2 for x6
+
+	mulpd	%xmm2,%xmm4				# x2(s5+x2s6)
+	mulpd	%xmm3,%xmm5				# x2(s5+x2s6)
+	mulpd	%xmm2,%xmm8				# x2(s2+x2s3)
+	mulpd	%xmm3,%xmm9				# x2(s2+x2s3)
+
+	mulpd	%xmm10,%xmm12				# x6
+	mulpd	%xmm11,%xmm13				# x6
+
+	addpd	.Lcossinarray+0x30(%rip),%xmm4		# s4+x2(s5+x2s6)
+	addpd	.Lsincosarray+0x30(%rip),%xmm5		# s4+x2(s5+x2s6)
+	addpd	.Lcossinarray(%rip),%xmm8		# s1+x2(s2+x2s3)
+	addpd	.Lsincosarray(%rip),%xmm9		# s1+x2(s2+x2s3)
+
+	movhlps	%xmm11,%xmm11				# move high x4 for cos term	+
+
+	mulpd	%xmm12,%xmm4				# x6(s4+x2(s5+x2s6))
+	mulpd	%xmm13,%xmm5				# x6(s4+x2(s5+x2s6))
+
+	movhlps	%xmm2,%xmm6				# move low x2 for x3 for sin term
+	movsd	%xmm3,%xmm7				# move low x2 for x3 for sin term   	+
+	mulsd	p_temp2+8(%rsp),%xmm6		# get low x3 for sin term
+	mulsd	%xmm1,%xmm7				# get low x3 for sin term		+
+
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for sin and cos terms
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for sin and cos terms
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm2,%xmm12				# move high 0.5*x2 for sin term
+	movhlps	%xmm3,%xmm13				# move high r for cos
+
+	movhlps	%xmm4,%xmm8				# xmm8 = sin , xmm4 = cos
+	movhlps	%xmm5,%xmm9				# xmm9 = cos , xmm5 = sin
+
+	mulsd	%xmm6,%xmm8				# sin *x3
+	mulsd	%xmm11,%xmm9				# cos *x4
+	mulsd	%xmm10,%xmm4				# cos *x4
+	mulsd	%xmm7,%xmm5				# sin *x3
+
+	mulsd	p_temp+8(%rsp),%xmm12		# 0.5 * x2 * xx for sin term
+	mulsd	p_temp1(%rsp),%xmm3		# 0.5 * x2 * xx for sin term
+
+	movsd	%xmm2,%xmm6				# Keep high r for cos term
+	movsd	%xmm13,%xmm7				# Keep high r for cos term
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm2 	#-t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13 	#-t=r-1.0
+
+	subsd	%xmm12,%xmm8				# sin - 0.5 * x2 *xx
+	subsd	%xmm3,%xmm5				# sin - 0.5 * x2 *xx
+
+	movhlps	%xmm0,%xmm10				# move high x for x for sin term
+	movhlps	%xmm1,%xmm11				# move high x for x*xx for cos term
+
+	mulsd	p_temp(%rsp),%xmm0		# x * xx
+	mulsd	p_temp1+8(%rsp),%xmm11		# x * xx
+
+	movsd	%xmm2,%xmm12				# move -t for cos term
+	movsd	%xmm13,%xmm3				# move -t for cos term
+
+	addsd	.L__real_3ff0000000000000(%rip),%xmm2 	# 1+(-t)
+	addsd	.L__real_3ff0000000000000(%rip),%xmm13	# 1+(-t)
+
+	addsd	p_temp+8(%rsp),%xmm8		# sin+xx
+	addsd	p_temp1(%rsp),%xmm5		# sin+xx
+
+	subsd	%xmm6,%xmm2				# (1-t) - r
+	subsd	%xmm7,%xmm13				# (1-t) - r
+
+	subsd	%xmm0,%xmm2				# ((1 + (-t)) - r) - x*xx
+	subsd	%xmm11,%xmm13				# ((1 + (-t)) - r) - x*xx
+
+
+	addsd	%xmm10,%xmm8				# sin + x
+	addsd	%xmm1,%xmm5				# sin + x
+
+	addsd   %xmm2,%xmm4				# cos+((1-t)-r - x*xx)
+	addsd   %xmm13,%xmm9				# cos+((1-t)-r - x*xx)
+
+	subsd   %xmm12,%xmm4				# cos+t
+	subsd   %xmm3,%xmm9				# cos+t
+
+	movlhps	%xmm8,%xmm4
+	movlhps	%xmm9,%xmm5
+	jmp 	.L__vrd4_sin_cleanup
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcoscos_sinsin_piby4:
+
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lsinarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lcosarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lsinarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lcosarray+0x20(%rip),%xmm9			# c3
+
+	movapd	 %xmm2,p_temp2(%rsp)			# store x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11	# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+	movapd	%xmm11,p_temp3(%rsp)			# store r
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	mulpd	%xmm2,%xmm10					# x4
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0
+
+	movapd	%xmm2,%xmm12					# copy of x2 for 0.5*x2
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lsinarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lcosarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lsinarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lcosarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm11	# 1 + (-t)
+
+	mulpd	%xmm2,%xmm10					# x6
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm12	# 0.5 *x2
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lsinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lcosarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm10,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm0,%xmm2					# x3 recalculate
+	mulpd	%xmm3,%xmm3					# x4 recalculate
+
+	movapd   p_temp3(%rsp),%xmm13			# r
+
+	mulpd	%xmm6,%xmm12					# 0.5 * x2 *xx
+	mulpd	%xmm1,%xmm7					# x * xx
+
+	subpd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm3,%xmm5					# x4 * zc
+
+	subpd	%xmm12,%xmm4					# -0.5 * x2 *xx
+	subpd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	addpd	%xmm6,%xmm4					# x3 * zs +xx
+	addpd   %xmm11,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm13	# t relaculate, -t = r-1
+	addpd	%xmm0,%xmm4					# +x
+	subpd   %xmm13,%xmm5					# + t
+
+	jmp	.L__vrd4_sin_cleanup
+
+.align 16
+.Lsinsin_coscos_piby4:
+
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lcosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lsinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lcosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lsinarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10	# r = 0.5 *x2
+	movapd	 %xmm3,p_temp3(%rsp)			# store x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+	movapd	 %xmm10,p_temp2(%rsp)			# store r
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0
+	mulpd	%xmm3,%xmm11					# x4
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for 0.5*x2
+
+	addpd	.Lcosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsinarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lcosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t)
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm11					# x6
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm13	# 0.5 *x2
+
+	addpd	.Lcosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lsinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm11,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zs
+
+	mulpd	%xmm2,%xmm2					# x4 recalculate
+	mulpd	%xmm1,%xmm3					# x3 recalculate
+
+	movapd   p_temp2(%rsp),%xmm12			# r
+
+	mulpd	%xmm0,%xmm6					# x * xx
+	mulpd	%xmm7,%xmm13					# 0.5 * x2 *xx
+	subpd   %xmm12,%xmm10					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x3 * zs
+
+	subpd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx;;;;;;;;;;;;;;;;;;;;;
+	subpd	%xmm13,%xmm5					# -0.5 * x2 *xx
+	addpd   %xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addpd	%xmm7,%xmm5					# +xx
+	subpd	.L__real_3ff0000000000000(%rip),%xmm12	# t relaculate, -t = r-1
+	addpd	%xmm1,%xmm5					# +x
+	subpd   %xmm12,%xmm4					# + t
+
+	jmp	.L__vrd4_sin_cleanup
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcoscos_cossin_piby4:				#Derive from cossin_coscos
+	movapd	%xmm2,%xmm10					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lsincosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lcosarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lsincosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lcosarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# r
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+	movapd	 %xmm6,p_temp(%rsp)			# rr
+	movhlps	 %xmm10,%xmm10					# get upper r for t for cos
+
+	mulpd	 %xmm2,%xmm8					# c3*x2
+	mulpd	 %xmm3,%xmm9					# c3*x2
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0  for cos
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lsincosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lcosarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lsincosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lcosarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addsd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t)
+	addpd   .L__real_3ff0000000000000(%rip),%xmm11	# 1 + (-t)
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lsincosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsincosarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lcosarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zc
+
+	movsd	%xmm0,%xmm8					# lower x for sin
+	mulsd	%xmm2,%xmm8					# lower x3 for sin
+
+	mulpd	%xmm2,%xmm2					# x4
+	mulpd	%xmm3,%xmm3					# upper x4 for cos
+	movsd	%xmm8,%xmm2					# lower x3 for sin
+
+	movsd	%xmm6,%xmm9					# lower xx
+								# note using odd reg
+
+	movlpd   p_temp2+8(%rsp),%xmm12		# upper r for cos term
+	movapd   p_temp3(%rsp),%xmm13			# r
+
+	mulpd	%xmm0,%xmm6					# x * xx for upper cos term
+	mulpd	%xmm1,%xmm7					# x * xx
+	movhlps	%xmm6,%xmm6
+	mulsd	p_temp2(%rsp),%xmm9 			# xx * 0.5*x2 for sin term
+
+	subsd   %xmm12,%xmm10					# (1 + (-t)) - r
+	subpd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x4 * zc
+								# x3 * zs
+
+	movhlps	%xmm4,%xmm8					# xmm8= cos, xmm4= sin
+
+	subsd	%xmm9,%xmm4					# x3zs - 0.5*x2*xx
+
+	subsd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx
+	subpd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	addsd   %xmm10,%xmm8					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addpd   %xmm11,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp(%rsp),%xmm4			# +xx
+
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12	# -t = r-1
+	subpd	.L__real_3ff0000000000000(%rip),%xmm13	# -t = r-1
+
+	subsd   %xmm12,%xmm8					# + t
+	addsd	%xmm0,%xmm4					# +x
+	subpd   %xmm13,%xmm5					# + t
+
+	movlhps	%xmm8,%xmm4
+
+	jmp	.L__vrd4_sin_cleanup
+
+.align 16
+.Lcoscos_sincos_piby4:		#Derive from sincos_coscos
+	movapd	%xmm2,%xmm10					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lcossinarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lcosarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lcossinarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lcosarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10	# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11	# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# r
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+	movapd	 %xmm6,p_temp(%rsp)			# rr
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0 for cos
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lcossinarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lcosarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lcossinarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lcosarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addsd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t) for cos
+	addpd   .L__real_3ff0000000000000(%rip),%xmm11	# 1 + (-t)
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lcossinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lcossinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lcosarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zszc
+	addpd	%xmm9,%xmm5					# z
+
+	mulpd	%xmm0,%xmm2					# upper x3 for sin
+	mulsd	%xmm0,%xmm2					# lower x4 for cos
+	mulpd	%xmm3,%xmm3					# x4
+
+	movhlps	%xmm6,%xmm9					# upper xx for sin term
+								# note using odd reg
+
+	movlpd  p_temp2(%rsp),%xmm12			# lower r for cos term
+	movapd  p_temp3(%rsp),%xmm13			# r
+
+
+	mulpd	%xmm0,%xmm6					# x * xx for lower cos term
+	mulpd	%xmm1,%xmm7					# x * xx
+
+	mulsd	p_temp2+8(%rsp),%xmm9 			# xx * 0.5*x2 for upper sin term
+
+	subsd   %xmm12,%xmm10					# (1 + (-t)) - r
+	subpd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# lower=x4 * zc
+								# upper=x3 * zs
+	mulpd	%xmm3,%xmm5
+								# x4 * zc
+
+	movhlps	%xmm4,%xmm8					# xmm8= sin, xmm4= cos
+	subsd	%xmm9,%xmm8					# x3zs - 0.5*x2*xx
+
+
+	subsd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx
+	subpd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	addsd   %xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addpd   %xmm11,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp+8(%rsp),%xmm8			# +xx
+
+	movhlps	%xmm0,%xmm0					# upper x for sin
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12	# -t = r-1
+	subpd	.L__real_3ff0000000000000(%rip),%xmm13	# -t = r-1
+
+	subsd   %xmm12,%xmm4					# + t
+	subpd   %xmm13,%xmm5					# + t
+	addsd	%xmm0,%xmm8					# +x
+
+	movlhps	%xmm8,%xmm4
+
+	jmp	.L__vrd4_sin_cleanup
+
+.align 16
+.Lcossin_coscos_piby4:
+	movapd	%xmm2,%xmm10					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lcosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lsincosarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lcosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lsincosarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# r
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+	movapd	 %xmm7,p_temp1(%rsp)			# rr
+	movhlps	%xmm11,%xmm11					# get upper r for t for cos
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0 for cos
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lcosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsincosarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lcosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsincosarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm10		# 1 + (-t)	;trash t
+	addsd   .L__real_3ff0000000000000(%rip),%xmm11		# 1 + (-t)	;trash t
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lcosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsincosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray(%rip),%xmm8				# c1 + x2(c2+x2C3)
+	addpd	.Lsincosarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zcs
+
+	movsd	%xmm1,%xmm9					# lower x for sin
+	mulsd	%xmm3,%xmm9					# lower x3 for sin
+
+	mulpd	%xmm2,%xmm2					# x4
+	mulpd	%xmm3,%xmm3					# upper x4 for cos
+	movsd	%xmm9,%xmm3					# lower x3 for sin
+
+	movsd	 %xmm7,%xmm8					# lower xx
+								# note using even reg
+
+	movapd   p_temp2(%rsp),%xmm12			# r
+	movlpd   p_temp3+8(%rsp),%xmm13		# upper r for cos term
+
+	mulpd	%xmm0,%xmm6					# x * xx
+	mulpd	%xmm1,%xmm7					# x * xx for upper cos term
+	movhlps	%xmm7,%xmm7
+	mulsd	p_temp3(%rsp),%xmm8 			# xx * 0.5*x2 for sin term
+
+	subpd   %xmm12,%xmm10					# (1 + (-t)) - r
+	subsd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x4 * zc
+								# x3 * zs
+
+	movhlps	%xmm5,%xmm9					# xmm9= cos, xmm5= sin
+
+	subsd	%xmm8,%xmm5					# x3zs - 0.5*x2*xx
+
+	subpd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx
+	subsd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	addpd   %xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd   %xmm11,%xmm9					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp1(%rsp),%xmm5			# +xx
+
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm12		# t relaculate, -t = r-1
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13		# t relaculate, -t = r-1
+
+	subpd   %xmm12,%xmm4					# + t
+	subsd   %xmm13,%xmm9					# + t
+	addsd	%xmm1,%xmm5					# +x
+
+	movlhps	%xmm9,%xmm5
+
+	jmp	.L__vrd4_sin_cleanup
+
+.align 16
+.Lcossin_sinsin_piby4:		# Derived from sincos_sinsin
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lsinarray+0x50(%rip),%xmm4				# c6
+	movdqa	.Lsincosarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lsinarray+0x20(%rip),%xmm8				# c3
+	movapd	.Lsincosarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+	movapd	 %xmm7,p_temp1(%rsp)			# rr
+
+	movhlps	%xmm11,%xmm11
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0 for cos
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lsinarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsincosarray+0x40(%rip),%xmm5		# c5+x2c6
+	addpd	.Lsinarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsincosarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	mulpd	%xmm6,%xmm10					# 0.5*x2*xx
+	addsd   .L__real_3ff0000000000000(%rip),%xmm11	# 1 + (-t) for cos
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lsinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsincosarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lsincosarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zczs
+
+	movsd	%xmm3,%xmm12
+	mulsd	%xmm1,%xmm12					# low x3 for sin
+
+	mulpd	%xmm0, %xmm2					# x3
+	mulpd	%xmm3, %xmm3					# high x4 for cos
+	movsd	%xmm12,%xmm3					# low x3 for sin
+
+	movhlps	%xmm1,%xmm8					# upper x for cos term
+								# note using even reg
+	movlpd  p_temp3+8(%rsp),%xmm13			# upper r for cos term
+
+	mulsd	p_temp1+8(%rsp),%xmm8			# x * xx for upper cos term
+
+	mulsd	p_temp3(%rsp),%xmm7 			# xx * 0.5*x2 for lower sin term
+
+	subsd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm3,%xmm5					# lower=x4 * zc
+								# upper=x3 * zs
+
+	movhlps	%xmm5,%xmm9					# xmm9= cos, xmm5= sin
+
+	subsd	%xmm7,%xmm5					# x3zs - 0.5*x2*xx
+
+	subsd   %xmm8,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	subpd	%xmm10,%xmm4					# x3*zs - 0.5*x2*xx
+	addsd   %xmm11,%xmm9					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp1(%rsp),%xmm5			# +xx
+
+	addpd	%xmm6,%xmm4					# +xx
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13	# -t = r-1
+
+
+	addsd	%xmm1,%xmm5					# +x
+	addpd	%xmm0,%xmm4					# +x
+	subsd   %xmm13,%xmm9					# + t
+
+	movlhps	%xmm9,%xmm5
+
+	jmp	.L__vrd4_sin_cleanup
+
+.align 16
+.Lsincos_coscos_piby4:
+	movapd	%xmm2,%xmm10					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lcosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lcossinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lcosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lcossinarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# r
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+	movapd	 %xmm7,p_temp1(%rsp)			# rr
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0 for cos
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lcosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lcossinarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lcosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lcossinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t)
+	addsd   .L__real_3ff0000000000000(%rip),%xmm11	# 1 + (-t) for cos
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lcosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcossinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lcossinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zszc
+
+	mulpd	%xmm2,%xmm2					# x4
+	mulpd	%xmm1,%xmm3					# upper x3 for sin
+	mulsd	%xmm1,%xmm3					# lower x4 for cos
+
+	movhlps	%xmm7,%xmm8					# upper xx for sin term
+								# note using even reg
+
+	movapd  p_temp2(%rsp),%xmm12			# r
+	movlpd  p_temp3(%rsp),%xmm13			# lower r for cos term
+
+	mulpd	%xmm0,%xmm6					# x * xx
+	mulpd	%xmm1,%xmm7					# x * xx for lower cos term
+
+	mulsd	p_temp3+8(%rsp),%xmm8 			# xx * 0.5*x2 for upper sin term
+
+	subpd   %xmm12,%xmm10					# (1 + (-t)) - r
+	subsd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# lower=x4 * zc
+								# upper=x3 * zs
+
+	movhlps	%xmm5,%xmm9					# xmm9= sin, xmm5= cos
+
+	subsd	%xmm8,%xmm9					# x3zs - 0.5*x2*xx
+
+	subpd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx
+	subsd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	addpd   %xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd   %xmm11,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp1+8(%rsp),%xmm9				# +xx
+
+	movhlps	%xmm1,%xmm1					# upper x for sin
+	subpd	.L__real_3ff0000000000000(%rip),%xmm12		# -t = r-1
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13		# -t = r-1
+
+	subpd   %xmm12,%xmm4					# + t
+	subsd   %xmm13,%xmm5					# + t
+	addsd	%xmm1, %xmm9					# +x
+
+	movlhps	%xmm9, %xmm5
+
+	jmp	.L__vrd4_sin_cleanup
+
+
+.align 16
+.Lsincos_sinsin_piby4:		# Derived from sincos_coscos
+	movapd	%xmm2,%xmm10					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lsinarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lcossinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lsinarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lcossinarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm11,p_temp3(%rsp)			# r
+	movapd	 %xmm7,p_temp1(%rsp)			# rr
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0 for cos
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lsinarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lcossinarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lsinarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lcossinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	mulpd	%xmm6,%xmm10					# 0.5x2*xx
+	addsd   .L__real_3ff0000000000000(%rip),%xmm11	# 1 + (-t) for cos
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lsinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lcossinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lcossinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zszc
+
+	mulpd	%xmm0,%xmm2					# x3
+	mulpd	%xmm1,%xmm3					# upper x3 for sin
+	mulsd	%xmm1,%xmm3					# lower x4 for cos
+
+	movhlps	%xmm7,%xmm8					# upper xx for sin term
+								# note using even reg
+
+	movlpd  p_temp3(%rsp),%xmm13			# lower r for cos term
+
+	mulpd	%xmm1,%xmm7					# x * xx for lower cos term
+
+	mulsd	p_temp3+8(%rsp),%xmm8 			# xx * 0.5*x2 for upper sin term
+
+	subsd   %xmm13,%xmm11					# (1 + (-t)) - r
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm3,%xmm5					# lower=x4 * zc
+								# upper=x3 * zs
+
+	movhlps	%xmm5,%xmm9					# xmm9= sin, xmm5= cos
+
+	subsd	%xmm8,%xmm9					# x3zs - 0.5*x2*xx
+
+	subsd   %xmm7,%xmm11					# ((1 + (-t)) - r) - x*xx
+
+	subpd	%xmm10,%xmm4					# x3*zs - 0.5*x2*xx
+	addsd   %xmm11,%xmm5					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp1+8(%rsp),%xmm9			# +xx
+
+	movhlps	%xmm1,%xmm1					# upper x for sin
+	addpd	%xmm6,%xmm4					# +xx
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13	# -t = r-1
+
+	addsd	%xmm1,%xmm9					# +x
+	addpd	%xmm0,%xmm4					# +x
+	subsd   %xmm13,%xmm5					# + t
+
+	movlhps	%xmm9,%xmm5
+
+	jmp	.L__vrd4_sin_cleanup
+
+
+.align 16
+.Lsinsin_cossin_piby4:		# Derived from sincos_sinsin
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lsincosarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lsinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lsincosarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lsinarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10	# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11	# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# x2
+	movapd	 %xmm6,p_temp(%rsp)			# xx
+
+	movhlps	%xmm10,%xmm10
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0 for cos
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lsincosarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsinarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lsincosarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	mulpd	%xmm7,%xmm11					# 0.5*x2*xx
+	addsd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t) for cos
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lsincosarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsincosarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lsinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zs
+
+
+	movsd	%xmm2,%xmm13
+	mulsd	%xmm0,%xmm13					# low x3 for sin
+
+	mulpd	%xmm1,%xmm3					# x3
+	mulpd	%xmm2,%xmm2					# high x4 for cos
+	movsd	%xmm13,%xmm2					# low x3 for sin
+
+
+	movhlps	%xmm0,%xmm9					# upper x for cos term								; note using even reg
+	movlpd  p_temp2+8(%rsp),%xmm12				# upper r for cos term
+	mulsd	p_temp+8(%rsp),%xmm9				# x * xx for upper cos term
+	mulsd	p_temp2(%rsp),%xmm6 				# xx * 0.5*x2 for lower sin term
+	subsd   %xmm12,%xmm10					# (1 + (-t)) - r
+	mulpd	%xmm3,%xmm5					# x3 * zs
+	mulpd	%xmm2,%xmm4					# lower=x4 * zc
+								# upper=x3 * zs
+
+	movhlps	%xmm4,%xmm8					# xmm8= cos, xmm4= sin
+	subsd	%xmm6,%xmm4					# x3zs - 0.5*x2*xx
+
+	subsd   %xmm9,%xmm10					# ((1 + (-t)) - r) - x*xx
+
+	subpd	%xmm11,%xmm5					# x3*zs - 0.5*x2*xx
+
+	addsd   %xmm10,%xmm8					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp(%rsp),%xmm4			# +xx
+
+	addpd	%xmm7,%xmm5					# +xx
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12	# -t = r-1
+
+	addsd	%xmm0,%xmm4					# +x
+	addpd	%xmm1,%xmm5					# +x
+	subsd   %xmm12,%xmm8					# + t
+	movlhps	%xmm8,%xmm4
+
+	jmp	.L__vrd4_sin_cleanup
+
+.align 16
+.Lsinsin_sincos_piby4:		# Derived from sincos_coscos
+
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lcossinarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lsinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lcossinarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lsinarray+0x20(%rip),%xmm9			# c3
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm10		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+
+	movapd	 %xmm10,p_temp2(%rsp)			# r
+	movapd	 %xmm6,p_temp(%rsp)			# rr
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0 for cos
+
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+
+	addpd	.Lcossinarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsinarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lcossinarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	mulpd	%xmm7,%xmm11					# 0.5x2*xx
+	addsd   .L__real_3ff0000000000000(%rip),%xmm10	# 1 + (-t) for cos
+
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x6
+	mulpd	%xmm3,%xmm13					# x6
+
+	addpd	.Lcossinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lcossinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lsinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm12,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm13,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zszc
+
+	mulpd	%xmm1,%xmm3					# x3
+	mulpd	%xmm0,%xmm2					# upper x3 for sin
+	mulsd	%xmm0,%xmm2					# lower x4 for cos
+
+	movhlps	%xmm6,%xmm9					# upper xx for sin term
+								# note using even reg
+
+	movlpd  p_temp2(%rsp),%xmm12			# lower r for cos term
+
+	mulpd	%xmm0,%xmm6					# x * xx for lower cos term
+
+	mulsd	p_temp2+8(%rsp),%xmm9 			# xx * 0.5*x2 for upper sin term
+
+	subsd   %xmm12,%xmm10					# (1 + (-t)) - r
+
+	mulpd	%xmm3,%xmm5					# x3 * zs
+	mulpd	%xmm2,%xmm4					# lower=x4 * zc
+								# upper=x3 * zs
+
+	movhlps	%xmm4,%xmm8					# xmm9= sin, xmm5= cos
+
+	subsd	%xmm9,%xmm8					# x3zs - 0.5*x2*xx
+
+	subsd   %xmm6,%xmm10					# ((1 + (-t)) - r) - x*xx
+
+	subpd	%xmm11,%xmm5					# x3*zs - 0.5*x2*xx
+	addsd   %xmm10,%xmm4					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addsd	p_temp+8(%rsp),%xmm8			# +xx
+
+	movhlps	%xmm0,%xmm0					# upper x for sin
+	addpd	%xmm7,%xmm5					# +xx
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12	# -t = r-1
+
+
+	addsd	%xmm0,%xmm8					# +x
+	addpd	%xmm1,%xmm5					# +x
+	subsd   %xmm12,%xmm4					# + t
+
+	movlhps	%xmm8,%xmm4
+
+	jmp	.L__vrd4_sin_cleanup
+
+
+.align 16
+.Lsinsin_sinsin_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+#DEBUG
+#	xorpd   %xmm0, %xmm0
+#	xorpd   %xmm1, %xmm1
+#	jmp	.Lfinal_check
+#DEBUG
+
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lsinarray+0x50(%rip),%xmm4			# c6
+	movdqa	.Lsinarray+0x50(%rip),%xmm5			# c6
+	movapd	.Lsinarray+0x20(%rip),%xmm8			# c3
+	movapd	.Lsinarray+0x20(%rip),%xmm9			# c3
+
+	movapd	 %xmm2,p_temp2(%rsp)			# copy of x2
+	movapd	 %xmm3,p_temp3(%rsp)			# copy of x2
+
+	mulpd	%xmm2,%xmm4					# c6*x2
+	mulpd	%xmm3,%xmm5					# c6*x2
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	mulpd	%xmm2,%xmm10					# x4
+	mulpd	%xmm3,%xmm11					# x4
+
+	addpd	.Lsinarray+0x40(%rip),%xmm4			# c5+x2c6
+	addpd	.Lsinarray+0x40(%rip),%xmm5			# c5+x2c6
+	addpd	.Lsinarray+0x10(%rip),%xmm8			# c2+x2C3
+	addpd	.Lsinarray+0x10(%rip),%xmm9			# c2+x2C3
+
+	mulpd	%xmm2,%xmm10					# x6
+	mulpd	%xmm3,%xmm11					# x6
+
+	mulpd	%xmm2,%xmm4					# x2(c5+x2c6)
+	mulpd	%xmm3,%xmm5					# x2(c5+x2c6)
+	mulpd	%xmm2,%xmm8					# x2(c2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(c2+x2C3)
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm2		# 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm3		# 0.5 *x2
+
+	addpd	.Lsinarray+0x30(%rip),%xmm4			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray+0x30(%rip),%xmm5			# c4 + x2(c5+x2c6)
+	addpd	.Lsinarray(%rip),%xmm8			# c1 + x2(c2+x2C3)
+	addpd	.Lsinarray(%rip),%xmm9			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm6,%xmm2					# 0.5 * x2 *xx
+	mulpd	%xmm7,%xmm3					# 0.5 * x2 *xx
+
+	mulpd	%xmm10,%xmm4					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm11,%xmm5					# x6(c4 + x2(c5+x2c6))
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zs
+
+	movapd	p_temp2(%rsp),%xmm10			# x2
+	movapd	p_temp3(%rsp),%xmm11			# x2
+
+	mulpd	%xmm0,%xmm10					# x3
+	mulpd	%xmm1,%xmm11					# x3
+
+	mulpd	%xmm10,%xmm4					# x3 * zs
+	mulpd	%xmm11,%xmm5					# x3 * zs
+
+	subpd	%xmm2,%xmm4					# -0.5 * x2 *xx
+	subpd	%xmm3,%xmm5					# -0.5 * x2 *xx
+
+	addpd	%xmm6,%xmm4					# +xx
+	addpd	%xmm7,%xmm5					# +xx
+
+	addpd	%xmm0,%xmm4					# +x
+	addpd	%xmm1,%xmm5					# +x
+
+	jmp	.L__vrd4_sin_cleanup
diff --git a/src/gas/vrdasincos.S b/src/gas/vrdasincos.S
new file mode 100644
index 0000000..d31e98a
--- /dev/null
+++ b/src/gas/vrdasincos.S
@@ -0,0 +1,1710 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrdasincos.s
+#
+# An array implementation of the sincos libm function.
+#
+# Prototype:
+#
+#    void vrda_sincos(int n, double *x, double *ys, double *yc);
+#
+#Computes Sine of x for an array of input values.
+#Places the results into the supplied ys array.
+#Computes Cosine of x for an array of input values.
+#Places the results into the supplied yc array.
+#Does not perform error checking.
+#Denormal inputs may produce unexpected results
+#Author: Harsha Jagasia
+#Email:  harsha.jagasia@amd.com
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.data
+.align 16
+.L__real_7fffffffffffffff: 	.quad 0x07fffffffffffffff	#Sign bit zero
+				.quad 0x07fffffffffffffff
+.L__real_3ff0000000000000: 	.quad 0x03ff0000000000000	# 1.0
+				.quad 0x03ff0000000000000
+.L__real_v2p__27:		.quad 0x03e40000000000000	# 2p-27
+				.quad 0x03e40000000000000
+.L__real_3fe0000000000000: 	.quad 0x03fe0000000000000	# 0.5
+				.quad 0x03fe0000000000000
+.L__real_3fc5555555555555: 	.quad 0x03fc5555555555555	# 0.166666666666
+				.quad 0x03fc5555555555555
+.L__real_3fe45f306dc9c883: 	.quad 0x03fe45f306dc9c883	# twobypi
+				.quad 0x03fe45f306dc9c883
+.L__real_3ff921fb54400000: 	.quad 0x03ff921fb54400000	# piby2_1
+				.quad 0x03ff921fb54400000
+.L__real_3dd0b4611a626331: 	.quad 0x03dd0b4611a626331	# piby2_1tail
+				.quad 0x03dd0b4611a626331
+.L__real_3dd0b4611a600000: 	.quad 0x03dd0b4611a600000	# piby2_2
+				.quad 0x03dd0b4611a600000
+.L__real_3ba3198a2e037073: 	.quad 0x03ba3198a2e037073	# piby2_2tail
+				.quad 0x03ba3198a2e037073
+.L__real_fffffffff8000000: 	.quad 0x0fffffffff8000000	# mask for stripping head and tail
+				.quad 0x0fffffffff8000000
+.L__real_8000000000000000:	.quad 0x08000000000000000	# -0  or signbit
+				.quad 0x08000000000000000
+.L__reald_one_one:		.quad 0x00000000100000001	#
+				.quad 0
+.L__reald_two_two:		.quad 0x00000000200000002	#
+				.quad 0
+.L__reald_one_zero:		.quad 0x00000000100000000	# sin_cos_filter
+				.quad 0
+.L__reald_zero_one:		.quad 0x00000000000000001	#
+				.quad 0
+.L__reald_two_zero:		.quad 0x00000000200000000	#
+				.quad 0
+.L__realq_one_one:		.quad 0x00000000000000001	#
+				.quad 0x00000000000000001	#
+.L__realq_two_two:		.quad 0x00000000000000002	#
+				.quad 0x00000000000000002	#
+.L__real_1_x_mask:		.quad 0x0ffffffffffffffff	#
+				.quad 0x03ff0000000000000	#
+.L__real_zero:			.quad 0x00000000000000000	#
+				.quad 0x00000000000000000	#
+.L__real_one:			.quad 0x00000000000000001	#
+				.quad 0x00000000000000001	#
+.L__real_jt_mask:		.quad 0x0000000000000000F	#
+				.quad 0x00000000000000000	#
+.L__real_naninf_upper_sign_mask:	.quad 0x000000000ffffffff	#
+					.quad 0x000000000ffffffff	#
+.L__real_naninf_lower_sign_mask:	.quad 0x0ffffffff00000000	#
+					.quad 0x0ffffffff00000000	#
+
+.Lcosarray:
+	.quad	0x03fa5555555555555		# 0.0416667		   	c1
+	.quad	0x03fa5555555555555
+	.quad	0x0bf56c16c16c16967		# -0.00138889	   		c2
+	.quad	0x0bf56c16c16c16967
+	.quad	0x03efa01a019f4ec90		# 2.48016e-005			c3
+	.quad	0x03efa01a019f4ec90
+	.quad	0x0be927e4fa17f65f6		# -2.75573e-007			c4
+	.quad	0x0be927e4fa17f65f6
+	.quad	0x03e21eeb69037ab78		# 2.08761e-009			c5
+	.quad	0x03e21eeb69037ab78
+	.quad	0x0bda907db46cc5e42		# -1.13826e-011	   		c6
+	.quad	0x0bda907db46cc5e42
+.Lsinarray:
+	.quad	0x0bfc5555555555555		# -0.166667	   		s1
+	.quad	0x0bfc5555555555555
+	.quad	0x03f81111111110bb3		# 0.00833333	   		s2
+	.quad	0x03f81111111110bb3
+	.quad	0x0bf2a01a019e83e5c		# -0.000198413			s3
+	.quad	0x0bf2a01a019e83e5c
+	.quad	0x03ec71de3796cde01		# 2.75573e-006			s4
+	.quad	0x03ec71de3796cde01
+	.quad	0x0be5ae600b42fdfa7		# -2.50511e-008			s5
+	.quad	0x0be5ae600b42fdfa7
+	.quad	0x03de5e0b2f9a43bb8		# 1.59181e-010	   		s6
+	.quad	0x03de5e0b2f9a43bb8
+.Lsincosarray:
+	.quad	0x0bfc5555555555555		# -0.166667	   		s1
+	.quad	0x03fa5555555555555		# 0.0416667		   	c1
+	.quad	0x03f81111111110bb3		# 0.00833333	   		s2
+	.quad	0x0bf56c16c16c16967
+	.quad	0x0bf2a01a019e83e5c		# -0.000198413			s3
+	.quad	0x03efa01a019f4ec90
+	.quad	0x03ec71de3796cde01		# 2.75573e-006			s4
+	.quad	0x0be927e4fa17f65f6
+	.quad	0x0be5ae600b42fdfa7		# -2.50511e-008			s5
+	.quad	0x03e21eeb69037ab78
+	.quad	0x03de5e0b2f9a43bb8		# 1.59181e-010	   		s6
+	.quad	0x0bda907db46cc5e42
+
+
+.Lcossinarray:
+	.quad	0x03fa5555555555555		# 0.0416667		   	c1
+	.quad	0x0bfc5555555555555		# -0.166667	   		s1
+	.quad	0x0bf56c16c16c16967
+	.quad	0x03f81111111110bb3		# 0.00833333	   		s2
+	.quad	0x03efa01a019f4ec90
+	.quad	0x0bf2a01a019e83e5c		# -0.000198413			s3
+	.quad	0x0be927e4fa17f65f6
+	.quad	0x03ec71de3796cde01		# 2.75573e-006			s4
+	.quad	0x03e21eeb69037ab78
+	.quad	0x0be5ae600b42fdfa7		# -2.50511e-008			s5
+	.quad	0x0bda907db46cc5e42
+	.quad	0x03de5e0b2f9a43bb8		# 1.59181e-010	   		s6
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+        .weak vrda_sincos_
+        .set vrda_sincos_,__vrda_sincos__
+        .weak vrda_sincos__
+        .set vrda_sincos__,__vrda_sincos__
+
+.text
+    .align 16
+    .p2align 4,,15
+
+#x/* a FORTRAN subroutine implementation of array sincos
+#**     VRDA_SINCOS(N,X,YS,YC)
+# C equivalent*/
+#void vrda_sincos__( int * n, double *x, double *ys, double *yc)
+#{
+#       vrda_sincos(*n,x,y);
+#}
+.globl __vrda_sincos__
+    .type   __vrda_sincos__,@function
+__vrda_sincos__:
+    mov         (%rdi),%edi
+.align 16
+.p2align 4,,15
+
+# define local variable storage offsets
+.equ	save_xmm6,	0x00		# temporary for get/put bits operation
+.equ	save_xmm7,	0x10		# temporary for get/put bits operation
+.equ	save_xmm8,	0x20		# temporary for get/put bits operation
+.equ	save_xmm9,	0x30		# temporary for get/put bits operation
+.equ	save_xmm10,	0x40		# temporary for get/put bits operation
+.equ	save_xmm11,	0x50		# temporary for get/put bits operation
+.equ	save_xmm12,	0x60		# temporary for get/put bits operation
+.equ	save_xmm13,	0x70		# temporary for get/put bits operation
+.equ	save_xmm14,	0x80		# temporary for get/put bits operation
+.equ	save_xmm15,	0x90		# temporary for get/put bits operation
+
+.equ	save_rdi,	0x0A0
+.equ	save_rsi,	0x0B0
+.equ	save_rbx,	0x0C0
+
+.equ	r,		0x0D0		# pointer to r for remainder_piby2
+.equ	rr,		0x0E0		# pointer to r for remainder_piby2
+.equ	rsq,		0x0F0
+.equ	region,		0x0100		# pointer to r for remainder_piby2
+
+.equ	r1,		0x0110		# pointer to r for remainder_piby2
+.equ	rr1,		0x0120		# pointer to r for remainder_piby2
+.equ	rsq1,		0x0130
+.equ	region1,	0x0140		# pointer to r for remainder_piby2
+
+.equ	p_temp,		0x0150		# temporary for get/put bits operation
+.equ	p_temp1,	0x0160		# temporary for get/put bits operation
+
+.equ	p_temp2,	0x0170		# temporary for get/put bits operation
+.equ	p_temp3,	0x0180		# temporary for get/put bits operation
+
+.equ	p_temp4,	0x0190		# temporary for get/put bits operation
+.equ	p_temp5,	0x01A0		# temporary for get/put bits operation
+
+.equ	p_temp6,	0x01B0		# temporary for get/put bits operation
+.equ	p_temp7,	0x01C0		# temporary for get/put bits operation
+
+.equ	p_original,	0x01D0		# original x
+.equ	p_mask,		0x01E0		# original x
+.equ	p_signs,	0x01F0		# original x
+.equ	p_signc,	0x0200		# original x
+.equ	p_region,	0x0210
+
+.equ	p_original1,	0x0220		# original x
+.equ	p_mask1,	0x0230		# original x
+.equ	p_signs1,	0x0240		# original x
+.equ	p_signc1,	0x0250		# original x
+.equ	p_region1,	0x0260
+
+.equ	save_r12,	0x0270		# temporary for get/put bits operation
+.equ	save_r13,	0x0280		# temporary for get/put bits operation
+
+.equ	save_r14,	0x0290		# temporary for get/put bits operation
+.equ	save_r15,	0x02A0		# temporary for get/put bits operation
+
+.equ	save_xa,	0x02B0		# qword ; leave space for 4 args*****
+.equ	save_ysa,	0x02C0		# qword ; leave space for 4 args*****
+.equ	save_yca,	0x02D0		# qword ; leave space for 4 args*****
+
+.equ	save_nv,	0x02E0		# qword
+.equ	p_iter,		0x02F0		# qword	storage for number of loop iterations
+
+
+.globl vrda_sincos
+    .type   vrda_sincos,@function
+vrda_sincos:
+
+	sub		$0x0308,%rsp
+
+	mov		%r12,save_r12(%rsp)		# save r12
+	mov		%r13,save_r13(%rsp)		# save r13
+	mov		%rbx,save_rbx(%rsp)		# save rbx
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#START PROCESS INPUT
+# save the arguments
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+	mov		%rdx,save_ysa(%rsp)	# save ysin_array pointer
+	mov		%rcx,save_yca(%rsp)	# save ycos_array pointer
+#ifdef INTEGER64
+        mov             %rdi,%rax
+#else
+        mov             %edi,%eax
+        mov             %rax,%rdi
+#endif
+
+	mov		%rdi,save_nv(%rsp)	# save number of values
+						# see if too few values to call the main loop
+	shr		$2,%rax			# get number of iterations
+	jz		.L__vrda_cleanup	# jump if only single calls
+						# prepare the iteration counts
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	shl		$2,%rax
+	sub		%rax,%rdi		# compute number of extra single calls
+	mov		%rdi,save_nv(%rsp)	# save number of left over values
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#START LOOP
+.align 16
+.L__vrda_top:
+# build the input _m128d
+	movapd	.L__real_7fffffffffffffff(%rip),%xmm2
+	mov	.L__real_7fffffffffffffff(%rip),%rdx
+
+	mov	save_xa(%rsp),%rsi	# get x_array pointer
+	movlpd	(%rsi),%xmm0
+	movhpd	8(%rsi),%xmm0
+	mov	(%rsi),%rax
+	mov	8(%rsi),%rcx
+	movdqa	%xmm0,%xmm6
+	movdqa  %xmm0,p_original(%rsp)
+
+	prefetch	64(%rsi)
+	add		$32,%rsi
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+
+	movlpd	-16(%rsi), %xmm1
+	movhpd	-8(%rsi), %xmm1
+	mov	-16(%rsi), %r8
+	mov	-8(%rsi),  %r9
+	movdqa	 %xmm1,%xmm7
+	movdqa   %xmm1,p_original1(%rsp)
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#STARTMAIN
+
+andpd 	%xmm2,%xmm0	#Unsign
+andpd 	%xmm2,%xmm1	#Unsign
+
+and	%rdx,%rax
+and	%rdx,%rcx
+and	%rdx,%r8
+and	%rdx,%r9
+
+movdqa	%xmm0,%xmm12
+movdqa	%xmm1,%xmm13
+
+pcmpgtd		%xmm6,%xmm12
+pcmpgtd		%xmm7,%xmm13
+movdqa		%xmm12,%xmm6
+movdqa		%xmm13,%xmm7
+psrldq		$4,%xmm12
+psrldq		$4,%xmm13
+psrldq		$8,%xmm6
+psrldq		$8,%xmm7
+
+mov 	$0x3FE921FB54442D18,%rdx			#piby4	+
+mov	$0x411E848000000000,%r10			#5e5	+
+movapd	.L__real_3fe0000000000000(%rip),%xmm4		#0.5 for later use	+
+
+por	%xmm6,%xmm12
+por	%xmm7,%xmm13
+movd	%xmm12,%r12				#Move Sign to gpr **
+movd	%xmm13,%r13				#Move Sign to gpr **
+
+movapd	%xmm0,%xmm2				#x0
+movapd	%xmm1,%xmm3				#x1
+movapd	%xmm0,%xmm6				#x0
+movapd	%xmm1,%xmm7				#x1
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm2 = x, xmm4 =0.5, xmm6 =x
+# xmm3 = x, xmm5 =0.5, xmm7 =x
+.align 16
+.Leither_or_both_arg_gt_than_piby4:
+	cmp	%r10,%rax
+	jae	.Lfirst_or_next3_arg_gt_5e5
+
+	cmp	%r10,%rcx
+	jae	.Lsecond_or_next2_arg_gt_5e5
+
+	cmp	%r10,%r8
+	jae	.Lthird_or_fourth_arg_gt_5e5
+
+	cmp	%r10,%r9
+	jae	.Lfourth_arg_gt_5e5
+
+
+#      /* Find out what multiple of piby2 */
+#        npi2  = (int)(x * twobypi + 0.5);
+	movapd	.L__real_3fe45f306dc9c883(%rip),%xmm0
+	mulpd	%xmm0,%xmm2						# * twobypi
+	mulpd	%xmm0,%xmm3						# * twobypi
+
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	addpd	%xmm4,%xmm3						# +0.5, npi2
+
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm0		# piby2_1
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm1		# piby2_1
+
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+
+	xorpd	%xmm12,%xmm12
+
+	cvttpd2dq	%xmm3,%xmm5					# convert packed double to packed integers
+
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm9		# piby2_2
+
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+	cvtdq2pd	%xmm5,%xmm3					# and back to double.
+
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+
+	movd	%xmm4,%r8						# Region
+	movd	%xmm5,%r9						# Region
+
+	mov 	.L__reald_one_zero(%rip),%rdx			# compare value for cossin path
+	mov	%r8,%r10						# For Sign of Sin
+	mov	%r9,%r11
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm0						# npi2 * piby2_1;
+       mulpd	%xmm3,%xmm1						# npi2 * piby2_1;
+
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+       mulpd	%xmm3,%xmm9						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm0,%xmm6						# rhead  = x - npi2 * piby2_1;
+       subpd	%xmm1,%xmm7						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm0						# t
+       movapd	%xmm7,%xmm1						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm0						# rhead
+       subpd	%xmm9,%xmm1						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm3		# npi2 * piby2_2tail
+
+       subpd	%xmm0,%xmm6						# t-rhead
+       subpd	%xmm1,%xmm7						# t-rhead
+
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       subpd	%xmm7,%xmm9						# - ((t - rhead) - rtail)
+
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       addpd	%xmm3,%xmm9						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm4  = npi2 (int), xmm0 =rhead, xmm8 =rtail
+# xmm5  = npi2 (int), xmm1 =rhead, xmm9 =rtail
+
+	pand	.L__reald_one_one(%rip),%xmm4			#odd/even region for cos/sin
+	pand	.L__reald_one_one(%rip),%xmm5			#odd/even region for cos/sin
+
+	pcmpeqd		%xmm12,%xmm4
+	pcmpeqd		%xmm12,%xmm5
+
+	punpckldq	%xmm4,%xmm4
+	punpckldq	%xmm5,%xmm5
+
+	movapd		 %xmm4,p_region(%rsp)
+	movapd		 %xmm5,p_region1(%rsp)
+
+	shr	$1,%r10						#~AB+A~B, A is sign and B is upper bit of region
+	shr	$1,%r11						#~AB+A~B, A is sign and B is upper bit of region
+
+	mov	%r10,%rax
+	mov	%r11,%rcx
+
+	not 	%r12						#ADDED TO CHANGE THE LOGIC
+	not 	%r13						#ADDED TO CHANGE THE LOGIC
+	and	%r12,%r10
+	and	%r13,%r11
+
+	not	%rax
+	not	%rcx
+	not	%r12
+	not	%r13
+	and	%r12,%rax
+	and	%r13,%rcx
+
+	or	%rax,%r10
+	or	%rcx,%r11
+	and	.L__reald_one_one(%rip),%r10				#(~AB+A~B)&1
+	and	.L__reald_one_one(%rip),%r11				#(~AB+A~B)&1
+
+	mov	%r10,%r12
+	mov	%r11,%r13
+
+	and	%rdx,%r12				#mask out the lower sign bit leaving the upper sign bit
+	and	%rdx,%r13				#mask out the lower sign bit leaving the upper sign bit
+
+	shl	$63,%r10				#shift lower sign bit left by 63 bits
+	shl	$63,%r11				#shift lower sign bit left by 63 bits
+	shl	$31,%r12				#shift upper sign bit left by 31 bits
+	shl	$31,%r13				#shift upper sign bit left by 31 bits
+
+	mov 	 %r10,p_signs(%rsp)		#write out lower sign bit
+	mov 	 %r12,p_signs+8(%rsp)		#write out upper sign bit
+	mov 	 %r11,p_signs1(%rsp)		#write out lower sign bit
+	mov 	 %r13,p_signs1+8(%rsp)		#write out upper sign bit
+
+# GET_BITS_DP64(rhead-rtail, uy);			   		; originally only rhead
+# xmm4  = Sign, xmm0 =rhead, xmm8 =rtail
+# xmm5  = Sign, xmm1 =rhead, xmm9 =rtail
+	movapd	%xmm0,%xmm6						# rhead
+	movapd	%xmm1,%xmm7						# rhead
+
+	subpd	%xmm8,%xmm0						# r = rhead - rtail
+	subpd	%xmm9,%xmm1						# r = rhead - rtail
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm4  = Sign, xmm0 = r, xmm6 =rhead, xmm8 =rtail
+# xmm5  = Sign, xmm1 = r, xmm7 =rhead, xmm9 =rtail
+
+	subpd	%xmm0,%xmm6				#rr=rhead-r
+	subpd	%xmm1,%xmm7				#rr=rhead-r
+
+	movapd	%xmm0,%xmm2				#move r for r2
+	movapd	%xmm1,%xmm3				#move r for r2
+
+	mulpd	%xmm0,%xmm2				#r2
+	mulpd	%xmm1,%xmm3				#r2
+
+	subpd	%xmm8,%xmm6				#rr=(rhead-r) -rtail
+	subpd	%xmm9,%xmm7				#rr=(rhead-r) -rtail
+
+
+	add	.L__reald_one_one(%rip),%r8
+	add	.L__reald_one_one(%rip),%r9
+
+	and	.L__reald_two_two(%rip),%r8
+	and	.L__reald_two_two(%rip),%r9
+
+	shr	$1,%r8
+	shr	$1,%r9
+
+	mov	%r8,%r12
+	mov	%r9,%r13
+
+	and	.L__reald_one_zero(%rip),%r12	#mask out the lower sign bit leaving the upper sign bit
+	and	.L__reald_one_zero(%rip),%r13	#mask out the lower sign bit leaving the upper sign bit
+
+	shl	$63,%r8				#shift lower sign bit left by 63 bits
+	shl	$63,%r9				#shift lower sign bit left by 63 bits
+
+	shl	$31,%r12				#shift upper sign bit left by 31 bits
+	shl	$31,%r13				#shift upper sign bit left by 31 bits
+
+	mov 	 %r8,p_signc(%rsp)		#write out lower sign bit
+	mov 	 %r12,p_signc+8(%rsp)		#write out upper sign bit
+	mov 	 %r9,p_signc1(%rsp)		#write out lower sign bit
+	mov 	 %r13,p_signc1+8(%rsp)		#write out upper sign bit
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lsinsin_sinsin_piby4:
+
+	movapd	 %xmm0,p_temp(%rsp)			# copy of x
+	movapd	 %xmm1,p_temp1(%rsp)			# copy of x
+
+	movapd	%xmm2,%xmm10					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lsinarray+0x50(%rip),%xmm4			# s6
+	movdqa	.Lsinarray+0x50(%rip),%xmm5			# s6
+	movapd	.Lsinarray+0x20(%rip),%xmm8			# s3
+	movapd	.Lsinarray+0x20(%rip),%xmm9			# s3
+
+	movdqa	.Lcosarray+0x50(%rip),%xmm12			# c6
+	movdqa	.Lcosarray+0x50(%rip),%xmm13			# c6
+	movapd	.Lcosarray+0x20(%rip),%xmm14			# c3
+	movapd	.Lcosarray+0x20(%rip),%xmm15			# c3
+
+	movapd	 %xmm2,p_temp2(%rsp)			# copy of x2
+	movapd	 %xmm3,p_temp3(%rsp)			# copy of x2
+
+	mulpd	%xmm2,%xmm4					# s6*x2
+	mulpd	%xmm3,%xmm5					# s6*x2
+	mulpd	%xmm2,%xmm8					# s3*x2
+	mulpd	%xmm3,%xmm9					# s3*x2
+
+	mulpd	%xmm2,%xmm12					# s6*x2
+	mulpd	%xmm3,%xmm13					# s6*x2
+	mulpd	%xmm2,%xmm14					# s3*x2
+	mulpd	%xmm3,%xmm15					# s3*x2
+
+	mulpd	%xmm2,%xmm10					# x4
+	mulpd	%xmm3,%xmm11					# x4
+
+	addpd	.Lsinarray+0x40(%rip),%xmm4			# s5+x2s6
+	addpd	.Lsinarray+0x40(%rip),%xmm5			# s5+x2s6
+	addpd	.Lsinarray+0x10(%rip),%xmm8			# s2+x2C3
+	addpd	.Lsinarray+0x10(%rip),%xmm9			# s2+x2C3
+
+	addpd	.Lcosarray+0x40(%rip),%xmm12			# c5+x2c6
+	addpd	.Lcosarray+0x40(%rip),%xmm13			# c5+x2c6
+	addpd	.Lcosarray+0x10(%rip),%xmm14			# c2+x2C3
+	addpd	.Lcosarray+0x10(%rip),%xmm15			# c2+x2C3
+
+	mulpd	%xmm2,%xmm10					# x6
+	mulpd	%xmm3,%xmm11					# x6
+
+	mulpd	%xmm2,%xmm4					# x2(s5+x2s6)
+	mulpd	%xmm3,%xmm5					# x2(s5+x2s6)
+	mulpd	%xmm2,%xmm8					# x2(s2+x2C3)
+	mulpd	%xmm3,%xmm9					# x2(s2+x2C3)
+
+	mulpd	%xmm2,%xmm12					# x2(s5+x2s6)
+	mulpd	%xmm3,%xmm13					# x2(s5+x2s6)
+	mulpd	%xmm2,%xmm14					# x2(s2+x2C3)
+	mulpd	%xmm3,%xmm15					# x2(s2+x2C3)
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm2		# 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm3		# 0.5 *x2
+
+	addpd	.Lsinarray+0x30(%rip),%xmm4			# s4 + x2(s5+x2s6)
+	addpd	.Lsinarray+0x30(%rip),%xmm5			# s4 + x2(s5+x2s6)
+	addpd	.Lsinarray(%rip),%xmm8			# s1 + x2(s2+x2C3)
+	addpd	.Lsinarray(%rip),%xmm9			# s1 + x2(s2+x2C3)
+
+	movapd	 %xmm2,p_temp4(%rsp)			# copy of r
+	movapd	 %xmm3,p_temp5(%rsp)			# copy of r
+
+	movapd	%xmm2,%xmm0					# r
+	movapd	%xmm3,%xmm1					# r
+
+	addpd	.Lcosarray+0x30(%rip),%xmm12			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray+0x30(%rip),%xmm13			# c4 + x2(c5+x2c6)
+	addpd	.Lcosarray(%rip),%xmm14			# c1 + x2(c2+x2C3)
+	addpd	.Lcosarray(%rip),%xmm15			# c1 + x2(c2+x2C3)
+
+	mulpd	%xmm6,%xmm2					# 0.5 * x2 *xx
+	mulpd	%xmm7,%xmm3					# 0.5 * x2 *xx
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm0		# -t=r-1.0
+	subpd	.L__real_3ff0000000000000(%rip),%xmm1		# -t=r-1.0
+
+	mulpd	%xmm10,%xmm4					# x6(s4 + x2(s5+x2s6))
+	mulpd	%xmm11,%xmm5					# x6(s4 + x2(s5+x2s6))
+
+	mulpd	%xmm10,%xmm12					# x6(c4 + x2(c5+x2c6))
+	mulpd	%xmm11,%xmm13					# x6(c4 + x2(c5+x2c6))
+
+	addpd   .L__real_3ff0000000000000(%rip),%xmm0		# 1+(-t)
+	addpd   .L__real_3ff0000000000000(%rip),%xmm1		# 1+(-t)
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zs
+
+	addpd	%xmm14,%xmm12					# zc
+	addpd	%xmm15,%xmm13					# zc
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = 0.5 * x2 *xx, xmm4 = zs, xmm12 = zc, xmm6 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = 0.5 * x2 *xx, xmm5 = zs, xmm13 = zc, xmm7 =rr
+
+# Free
+# %xmm8,,%xmm10 xmm14
+# %xmm9,,%xmm11 xmm15
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	p_temp2(%rsp),%xmm10			# x2 for x3
+	movapd	p_temp3(%rsp),%xmm11			# x2 for x3
+
+	movapd	%xmm10,%xmm8					# x2 for x4
+	movapd	%xmm11,%xmm9					# x2 for x4
+
+	movapd	p_temp(%rsp),%xmm14			# x for x*xx
+	movapd	p_temp1(%rsp),%xmm15			# x for x*xx
+
+	subpd   p_temp4(%rsp),%xmm0			# (1 + (-t)) - r
+	subpd   p_temp5(%rsp),%xmm1			# (1 + (-t)) - r
+
+	mulpd	%xmm14,%xmm10					# x3
+	mulpd	%xmm15,%xmm11					# x3
+
+	mulpd	%xmm8,%xmm8					# x4
+	mulpd	%xmm9,%xmm9					# x4
+
+	mulpd	%xmm6,%xmm14					# x*xx
+	mulpd	%xmm7,%xmm15					# x*xx
+
+	mulpd	%xmm10,%xmm4					# x3 * zs
+	mulpd	%xmm11,%xmm5					# x3 * zs
+
+	mulpd	%xmm8,%xmm12					# x4 * zc
+	mulpd	%xmm9,%xmm13					# x4 * zc
+
+	subpd	%xmm2,%xmm4					# x3*zs-0.5 * x2 *xx
+	subpd	%xmm3,%xmm5					# x3*zs-0.5 * x2 *xx
+
+	subpd   %xmm14,%xmm0					# ((1 + (-t)) - r) -x*xx
+	subpd   %xmm15,%xmm1					# ((1 + (-t)) - r) -x*xx
+
+
+	movapd	p_temp4(%rsp),%xmm10			# r for t
+	movapd	p_temp5(%rsp),%xmm11			# r for t
+
+	addpd	%xmm6,%xmm4					# sin+xx
+	addpd	%xmm7,%xmm5					# sin+xx
+
+	addpd   %xmm0,%xmm12					# x4*zc + (((1 + (-t)) - r) - x*xx)
+	addpd   %xmm1,%xmm13					# x4*zc + (((1 + (-t)) - r) - x*xx)
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm10	# -t=r-1.0
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0
+
+	movapd	p_region(%rsp),%xmm2
+	movapd	p_region1(%rsp),%xmm3
+
+	movapd	%xmm2,%xmm8
+	movapd	%xmm3,%xmm9
+
+	addpd	p_temp(%rsp),%xmm4			# sin+xx+x
+	addpd	p_temp1(%rsp),%xmm5			# sin+xx+x
+
+	subpd	%xmm10,%xmm12					# cos + (-t)
+	subpd	%xmm11,%xmm13					# cos + (-t)
+
+# xmm4	= sin, xmm5  = sin
+# xmm12	= cos, xmm13 = cos
+
+	andnpd	%xmm4,%xmm8
+	andnpd	%xmm5,%xmm9
+
+	andpd	%xmm2,%xmm4
+	andpd	%xmm3,%xmm5
+
+	andnpd	%xmm12,%xmm2
+	andnpd	%xmm13,%xmm3
+
+	andpd	p_region(%rsp),%xmm12
+	andpd	p_region1(%rsp),%xmm13
+
+	orpd	%xmm2,%xmm4
+	orpd	%xmm3,%xmm5
+
+	orpd	%xmm8,%xmm12
+	orpd	%xmm9,%xmm13
+
+	jmp 	.L__vrd4_sin_cleanup
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lfirst_or_next3_arg_gt_5e5:
+# %rcx,,%rax r8, r9
+
+	cmp	%r10,%rcx				#is upper arg >= 5e5
+	jae	.Lboth_arg_gt_5e5
+
+.Llower_arg_gt_5e5:
+# Upper Arg is < 5e5, Lower arg is >= 5e5
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+# Be sure not to use %xmm3,%xmm1 and xmm7
+# Use %xmm8,,%xmm5 xmm10, xmm12
+#	    %xmm11,,%xmm9 xmm13
+
+
+	movlpd	 %xmm0,r(%rsp)		#Save lower fp arg for remainder_piby2 call
+	movhlps	%xmm0,%xmm0			#Needed since we want to work on upper arg
+	movhlps	%xmm2,%xmm2
+	movhlps	%xmm6,%xmm6
+
+# Work on Upper arg
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm4,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm8		# xmm8 = piby2_1
+	cvttsd2si	%xmm2,%ecx				# ecx = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm10		# xmm10 = piby2_2
+	cvtsi2sd	%ecx,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm8					# npi2 * piby2_1
+	subsd	%xmm8,%xmm6					# xmm6 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm12		# xmm12 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm6,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm10					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm10,%xmm6					# xmm6 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm12     					# npi2 * piby2_2tail
+       subsd	%xmm6,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm10					# (rtail-(t-rhead))
+       addsd	%xmm12,%xmm10					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %ecx,region+4(%rsp)			# store upper region
+       movsd	 %xmm6,%xmm0
+       subsd	 %xmm10,%xmm0					# xmm0 = r=(rhead-rtail)
+       subsd	 %xmm0,%xmm6					# rr=rhead-r
+       subsd	 %xmm10,%xmm6					# xmm6 = rr=((rhead-r) -rtail)
+       movlpd	 %xmm0,r+8(%rsp)			# store upper r
+       movlpd	 %xmm6,rr+8(%rsp)			# store upper rr
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#Note that volatiles will be trashed by the call
+#We will construct r, rr, region and sign
+
+# Work on Lower arg
+	mov		$0x07ff0000000000000,%r11			# is lower arg nan/inf
+	mov		%r11,%r10
+	and		%rax,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_sin_lower_naninf
+
+	mov	  %r8,p_temp(%rsp)
+	mov	  %r9,p_temp2(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region(%rsp),%rdx			# lower arg is **NOT** nan/inf
+	lea	 rr(%rsp),%rsi
+	lea	 r(%rsp),%rdi
+	movlpd	 r(%rsp),%xmm0	#Restore lower fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+
+	mov	 p_temp(%rsp),%r8
+	mov	 p_temp2(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+	jmp 	0f
+
+.L__vrd4_sin_lower_naninf:
+	mov	p_original(%rsp),%rax			# upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rax
+	mov	 %rax,r(%rsp)				# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr(%rsp)				# rr = 0
+	mov	 %r10d,region(%rsp)			# region =0
+	and 	.L__real_naninf_lower_sign_mask(%rip),%r12	# Sign
+.align 16
+0:
+	jmp 	.Lcheck_next2_args
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lboth_arg_gt_5e5:
+#Upper Arg is >= 5e5, Lower arg is >= 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+
+	movhpd 	%xmm0,r+8(%rsp)				#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r11			#is lower arg nan/inf
+	mov		%r11,%r10
+	and		%rax,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_sin_lower_naninf_of_both_gt_5e5
+
+	mov	  %rcx,p_temp(%rsp)			#Save upper arg
+	mov	  %r8,p_temp2(%rsp)
+	mov	  %r9,p_temp4(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	 rr(%rsp),%rsi
+	lea	 r(%rsp),%rdi
+        call    __amd_remainder_piby2@PLT
+
+	mov	 p_temp(%rsp),%rcx			#Restore upper arg
+	mov	 p_temp2(%rsp),%r8
+	mov	 p_temp4(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+
+	jmp 	0f
+
+.L__vrd4_sin_lower_naninf_of_both_gt_5e5:				#lower arg is nan/inf
+	mov	p_original(%rsp),%rax
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rax
+	mov	 %rax,r(%rsp)				#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr(%rsp)				#rr = 0
+	mov	 %r10d,region(%rsp)			#region = 0
+	and 	.L__real_naninf_lower_sign_mask(%rip),%r12	# Sign
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r11			#is upper arg nan/inf
+	mov		%r11,%r10
+	and		%rcx,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_sin_upper_naninf_of_both_gt_5e5
+
+
+	mov	  %r8,p_temp(%rsp)
+	mov	  %r9,p_temp2(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region+4(%rsp),%rdx			#upper arg is **NOT** nan/inf
+	lea	 rr+8(%rsp),%rsi
+	lea	 r+8(%rsp),%rdi
+	movlpd	 r+8(%rsp),%xmm0			#Restore upper fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+
+	mov	 p_temp(%rsp),%r8
+	mov	 p_temp2(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+
+	jmp 	0f
+
+.L__vrd4_sin_upper_naninf_of_both_gt_5e5:
+	mov	p_original+8(%rsp),%rcx				#upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rcx
+	mov	%rcx,r+8(%rsp)					#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	%r10,rr+8(%rsp)					#rr = 0
+	mov	%r10d,region+4(%rsp)				#region = 0
+	and 	.L__real_naninf_upper_sign_mask(%rip),%r12	# Sign
+.align 16
+0:
+	jmp 	.Lcheck_next2_args
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lsecond_or_next2_arg_gt_5e5:
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+# Do not use %xmm3,,%xmm1 xmm7
+# Restore xmm4 and %xmm3,,%xmm1 xmm7
+# Can use %xmm10,,%xmm8 xmm12
+#   %xmm9,,%xmm5 xmm11, xmm13
+
+	movhpd	 %xmm0,r+8(%rsp)		#Save upper fp arg for remainder_piby2 call
+#	movlhps	%xmm0,%xmm0			#Not needed since we want to work on lower arg, but done just to be safe and avoide exceptions due to nan/inf and to mirror the lower_arg_gt_5e5 case
+#	movlhps	%xmm2,%xmm2
+#	movlhps	%xmm6,%xmm6
+
+# Work on Lower arg
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm4,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm8		# xmm3 = piby2_1
+	cvttsd2si	%xmm2,%eax				# ecx = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm10		# xmm1 = piby2_2
+	cvtsi2sd	%eax,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm8					# npi2 * piby2_1
+	subsd	%xmm8,%xmm6					# xmm6 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm12		# xmm7 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm6,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm10					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm10,%xmm6					# xmm6 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm12     					# npi2 * piby2_2tail
+       subsd	%xmm6,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm10					# (rtail-(t-rhead))
+       addsd	%xmm12,%xmm10					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %eax,region(%rsp)			# store upper region
+       movsd	%xmm6,%xmm0
+       subsd	%xmm10,%xmm0					# xmm0 = r=(rhead-rtail)
+       subsd	%xmm0,%xmm6					# rr=rhead-r
+       subsd	%xmm10,%xmm6					# xmm6 = rr=((rhead-r) -rtail)
+       movlpd	 %xmm0,r(%rsp)				# store upper r
+       movlpd	 %xmm6,rr(%rsp)				# store upper rr
+
+#Work on Upper arg
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+	mov		$0x07ff0000000000000,%r11			# is upper arg nan/inf
+	mov		%r11,%r10
+	and		%rcx,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_sin_upper_naninf
+
+
+	mov	  %r8,p_temp(%rsp)
+	mov	  %r9,p_temp2(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 rr+8(%rsp),%rsi
+	lea	 r+8(%rsp),%rdi
+	movlpd	 r+8(%rsp),%xmm0	#Restore upper fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+
+	mov	p_temp(%rsp),%r8
+	mov	p_temp2(%rsp),%r9
+	movapd	p_temp1(%rsp),%xmm1
+	movapd	p_temp3(%rsp),%xmm3
+	movapd	p_temp5(%rsp),%xmm7
+	jmp 	0f
+
+.L__vrd4_sin_upper_naninf:
+	mov	p_original+8(%rsp),%rcx		# upper arg is nan/inf
+#	mov	r+8(%rsp),%rcx				; upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rcx
+	mov	 %rcx,r+8(%rsp)				# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr+8(%rsp)			# rr = 0
+	mov	 %r10d,region+4(%rsp)			# region =0
+	and 	.L__real_naninf_upper_sign_mask(%rip),%r12	# Sign
+
+.align 16
+0:
+	jmp 	.Lcheck_next2_args
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcheck_next2_args:
+
+	mov	$0x411E848000000000,%r10			#5e5	+
+
+	cmp	%r10,%r8
+	jae	.Lfirst_second_done_third_or_fourth_arg_gt_5e5
+
+	cmp	%r10,%r9
+	jae	.Lfirst_second_done_fourth_arg_gt_5e5
+
+# Work on next two args, both < 5e5
+# %xmm3,,%xmm1 xmm5 = x, xmm4 = 0.5
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4			# Restore 0.5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm3						# * twobypi
+	addpd	%xmm4,%xmm3						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm1		# piby2_1
+	cvttpd2dq	%xmm3,%xmm5					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm9		# piby2_2
+	cvtdq2pd	%xmm5,%xmm3					# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movq	 %xmm5,region1(%rsp)						# Region
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm3,%xmm1						# npi2 * piby2_1;
+
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm3,%xmm9						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm1,%xmm7						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm7,%xmm1						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm9,%xmm1						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm3		# npi2 * piby2_2tail
+
+       subpd	%xmm1,%xmm7						# t-rhead
+       subpd	%xmm7,%xmm9						# - ((t - rhead) - rtail)
+       addpd	%xmm3,%xmm9						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+       movapd	%xmm1,%xmm7						# rhead
+       subpd	%xmm9,%xmm1						# r = rhead - rtail
+       movapd	%xmm1,r1(%rsp)
+
+       subpd	%xmm1,%xmm7						# rr=rhead-r
+       subpd	%xmm9,%xmm7						# rr=(rhead-r) -rtail
+       movapd	%xmm7,rr1(%rsp)
+
+	jmp	.L__vrd4_sin_reconstruct
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lthird_or_fourth_arg_gt_5e5:
+#first two args are < 5e5, third arg >= 5e5, fourth arg >= 5e5 or < 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+# Do not use %xmm3,,%xmm1 xmm7
+# Can use 	%xmm11,,%xmm9 xmm13
+# 	%xmm8,,%xmm5 xmm10, xmm12
+# Restore xmm4
+
+# Work on first two args, both < 5e5
+
+#DEBUG
+#	movapd	%xmm2, %xmm4
+#	movapd	%xmm1, %xmm5
+#	movapd	%xmm2, %xmm12
+#	movapd	%xmm1, %xmm13
+#	jmp 	.L__vrd4_sin_cleanup
+#DEBUG
+
+	mulpd		.L__real_3fe45f306dc9c883(%rip),%xmm2						# * twobypi
+	addpd		%xmm4,%xmm2					# +0.5, npi2
+	movapd		.L__real_3ff921fb54400000(%rip),%xmm0		# piby2_1
+	cvttpd2dq	%xmm2,%xmm4				# convert packed double to packed integers
+	movapd		.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	cvtdq2pd	%xmm4,%xmm2				# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movq	 %xmm4,region(%rsp)						# Region
+
+#DEBUG
+#	movapd	region(%rsp), %xmm4
+#	movapd	%xmm1, %xmm5
+#	movapd	region(%rsp), %xmm12
+#	movapd	%xmm1, %xmm13
+#	jmp 	.L__vrd4_sin_cleanup
+#DEBUG
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm0						# npi2 * piby2_1;
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm0,%xmm6						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm0						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm0						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+
+       subpd	%xmm0,%xmm6						# t-rhead
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+       movapd	%xmm0,%xmm6						# rhead
+       subpd	%xmm8,%xmm0						# r = rhead - rtail
+       movapd	 %xmm0,r(%rsp)
+
+       subpd	%xmm0,%xmm6						# rr=rhead-r
+       subpd	%xmm8,%xmm6						# rr=(rhead-r) -rtail
+       movapd	 %xmm6,rr(%rsp)
+
+
+# Work on next two args, third arg >= 5e5, fourth arg >= 5e5 or < 5e5
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lfirst_second_done_third_or_fourth_arg_gt_5e5:
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+
+#DEBUG
+#	movapd	region(%rsp), %xmm4
+#	movapd	%xmm1, %xmm5
+#	movapd	region(%rsp), %xmm12
+#	movapd	%xmm1, %xmm13
+#	jmp 	.L__vrd4_sin_cleanup
+#DEBUG
+
+	mov	$0x411E848000000000,%r10			#5e5	+
+
+	cmp	%r10,%r9
+	jae	.Lboth_arg_gt_5e5_higher
+
+
+# Upper Arg is <5e5, Lower arg is >= 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+	movlpd	 %xmm1,r1(%rsp)				#Save lower fp arg for remainder_piby2 call
+	movhlps	%xmm1,%xmm1				#Needed since we want to work on upper arg
+	movhlps	%xmm3,%xmm3
+	movhlps	%xmm7,%xmm7
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4	#0.5 for later use
+
+# Work on Upper arg
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm3		# x*twobypi
+	addsd	%xmm4,%xmm3					# xmm3 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm2		# xmm2 = piby2_1
+	cvttsd2si	%xmm3,%r9d				# r9d = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm0		# xmm0 = piby2_2
+	cvtsi2sd	%r9d,%xmm3				# xmm3 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm3,%xmm2					# npi2 * piby2_1
+	subsd	%xmm2,%xmm7					# xmm7 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm7,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm3,%xmm0					# xmm0 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm0,%xmm7					# xmm7 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm3,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm7,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm0					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm0					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %r9d,region1+4(%rsp)			# store upper region
+       movsd	 %xmm7,%xmm1
+       subsd	 %xmm0,%xmm1					# xmm1 = r=(rhead-rtail)
+       subsd	 %xmm1,%xmm7					# rr=rhead-r
+       subsd	 %xmm0,%xmm7					# xmm7 = rr=((rhead-r) -rtail)
+       movlpd	 %xmm1,r1+8(%rsp)			# store upper r
+       movlpd	 %xmm7,rr1+8(%rsp)			# store upper rr
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+
+# Work on Lower arg
+	mov		$0x07ff0000000000000,%r11			# is lower arg nan/inf
+	mov		%r11,%r10
+	and		%r8,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_sin_lower_naninf_higher
+
+	lea	 region1(%rsp),%rdx			# lower arg is **NOT** nan/inf
+	lea	 rr1(%rsp),%rsi
+	lea	 r1(%rsp),%rdi
+	movlpd	 r1(%rsp),%xmm0				#Restore lower fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+	jmp 	0f
+
+.L__vrd4_sin_lower_naninf_higher:
+	mov	p_original1(%rsp),%r8			# upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r8
+	mov	 %r8,r1(%rsp)				# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr1(%rsp)				# rr = 0
+	mov	 %r10d,region1(%rsp)			# region =0
+	and 	.L__real_naninf_lower_sign_mask(%rip),%r13	# Sign
+
+.align 16
+0:
+
+
+#DEBUG
+#	movapd	r(%rsp), %xmm4
+#	movapd	r1(%rsp), %xmm5
+#	movapd	r(%rsp), %xmm12
+#	movapd	r1(%rsp), %xmm13
+#	jmp 	.L__vrd4_sin_cleanup
+#DEBUG
+
+
+	jmp 	.L__vrd4_sin_reconstruct
+
+.align 16
+.Lboth_arg_gt_5e5_higher:
+# Upper Arg is >= 5e5, Lower arg is >= 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+	movhpd 	%xmm1,r1+8(%rsp)		#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r11			#is lower arg nan/inf
+	mov		%r11,%r10
+	and		%r8,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_sin_lower_naninf_of_both_gt_5e5_higher
+
+	mov	 %r9,p_temp1(%rsp)			#Save upper arg
+	lea	 region1(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	 rr1(%rsp),%rsi
+	lea	 r1(%rsp),%rdi
+	movsd	 %xmm1,%xmm0
+        call    __amd_remainder_piby2@PLT
+	mov	 p_temp1(%rsp),%r9			#Restore upper arg
+
+	jmp 	0f
+
+.L__vrd4_sin_lower_naninf_of_both_gt_5e5_higher:				#lower arg is nan/inf
+	mov	p_original1(%rsp),%r8
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r8
+	mov	 %r8,r1(%rsp)				#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr1(%rsp)				#rr = 0
+	mov	 %r10d,region1(%rsp)			#region = 0
+	and 	.L__real_naninf_lower_sign_mask(%rip),%r13	# Sign
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r11			#is upper arg nan/inf
+	mov		%r11,%r10
+	and		%r9,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_sin_upper_naninf_of_both_gt_5e5_higher
+
+	lea	 region1+4(%rsp),%rdx			#upper arg is **NOT** nan/inf
+	lea	 rr1+8(%rsp),%rsi
+	lea	 r1+8(%rsp),%rdi
+	movlpd	 r1+8(%rsp),%xmm0			#Restore upper fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+	jmp 	0f
+
+.L__vrd4_sin_upper_naninf_of_both_gt_5e5_higher:
+	mov	p_original1+8(%rsp),%r9		#upper arg is nan/inf
+#	movd	%xmm6,%r9					;upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r9
+	mov	 %r9,r1+8(%rsp)				#r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	 %r10,rr1+8(%rsp)			#rr = 0
+	mov	 %r10d,region1+4(%rsp)			#region = 0
+	and 	.L__real_naninf_upper_sign_mask(%rip),%r13	# Sign
+
+.align 16
+0:
+
+	jmp 	.L__vrd4_sin_reconstruct
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lfourth_arg_gt_5e5:
+#first two args are < 5e5, third arg < 5e5, fourth arg >= 5e5
+#%rcx,,%rax r8, r9
+#%xmm2,,%xmm0 xmm6 = x, xmm4 = 0.5
+
+# Work on first two args, both < 5e5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm2						# * twobypi
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm0		# piby2_1
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movq	 %xmm4,region(%rsp)						# Region
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm0						# npi2 * piby2_1;
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm0,%xmm6						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm0						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm0						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+
+       subpd	%xmm0,%xmm6						# t-rhead
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+       movapd	%xmm0,%xmm6						# rhead
+       subpd	%xmm8,%xmm0						# r = rhead - rtail
+       movapd	 %xmm0,r(%rsp)
+
+       subpd	%xmm0,%xmm6						# rr=rhead-r
+       subpd	%xmm8,%xmm6						# rr=(rhead-r) -rtail
+       movapd	 %xmm6,rr(%rsp)
+
+
+# Work on next two args, third arg < 5e5, fourth arg >= 5e5
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lfirst_second_done_fourth_arg_gt_5e5:
+
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+	movhpd	 %xmm1,r1+8(%rsp)		#Save upper fp arg for remainder_piby2 call
+#	movlhps	%xmm1,%xmm1			#Not needed since we want to work on lower arg, but done just to be safe and avoide exceptions due to nan/inf and to mirror the lower_arg_gt_5e5 case
+#	movlhps	%xmm3,%xmm3
+#	movlhps	%xmm7,%xmm7
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4	#0.5 for later use
+
+# Work on Lower arg
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm3		# x*twobypi
+	addsd	%xmm4,%xmm3					# xmm3 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm2		# xmm2 = piby2_1
+	cvttsd2si	%xmm3,%r8d				# r8d = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm0		# xmm0 = piby2_2
+	cvtsi2sd	%r8d,%xmm3				# xmm3 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm3,%xmm2					# npi2 * piby2_1
+	subsd	%xmm2,%xmm7					# xmm7 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm7,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm3,%xmm0					# xmm0 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm0,%xmm7					# xmm7 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm3,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm7,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm0					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm0					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %r8d,region1(%rsp)			# store lower region
+       movsd	%xmm7,%xmm1
+       subsd	%xmm0,%xmm1					# xmm0 = r=(rhead-rtail)
+       subsd	%xmm1,%xmm7					# rr=rhead-r
+       subsd	%xmm0,%xmm7					# xmm6 = rr=((rhead-r) -rtail)
+
+       movlpd	 %xmm1,r1(%rsp)				# store upper r
+       movlpd	 %xmm7,rr1(%rsp)				# store upper rr
+
+#Work on Upper arg
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+	mov		$0x07ff0000000000000,%r11			# is upper arg nan/inf
+	mov		%r11,%r10
+	and		%r9,%r10
+	cmp		%r11,%r10
+	jz		.L__vrd4_sin_upper_naninf_higher
+
+	lea	 region1+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 rr1+8(%rsp),%rsi
+	lea	 r1+8(%rsp),%rdi
+	movlpd	 r1+8(%rsp),%xmm0	#Restore upper fp arg for remainder_piby2 call
+        call    __amd_remainder_piby2@PLT
+	jmp 	0f
+
+.L__vrd4_sin_upper_naninf_higher:
+	mov	p_original1+8(%rsp),%r9		# upper arg is nan/inf
+#	mov	r1+8(%rsp),%r9				; upper arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r9
+	mov	%r9,r1+8(%rsp)				# r = x | 0x0008000000000000
+	xor	%r10,%r10
+	mov	%r10,rr1+8(%rsp)			# rr = 0
+	mov	%r10d,region1+4(%rsp)			# region =0
+	and 	.L__real_naninf_upper_sign_mask(%rip),%r13	# Sign
+
+.align 16
+0:
+	jmp	.L__vrd4_sin_reconstruct
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrd4_sin_reconstruct:
+#Results
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm0 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#DEBUG
+#	movapd	region(%rsp), %xmm4
+#	movapd	region1(%rsp), %xmm5
+#	movapd	region(%rsp), %xmm12
+#	movapd	region1(%rsp), %xmm13
+#	jmp 	.L__vrd4_sin_cleanup
+#DEBUG
+
+
+	movapd	r(%rsp),%xmm0
+	movapd	r1(%rsp),%xmm1
+
+	movapd	rr(%rsp),%xmm6
+	movapd	rr1(%rsp),%xmm7
+
+	mov	region(%rsp),%r8
+	mov	region1(%rsp),%r9
+
+	movlpd	region(%rsp),%xmm4
+	movlpd	region1(%rsp),%xmm5
+
+	pand	.L__reald_one_one(%rip),%xmm4			#odd/even region for cos/sin
+	pand	.L__reald_one_one(%rip),%xmm5			#odd/even region for cos/sin
+
+	xorpd	%xmm12,%xmm12
+	pcmpeqd		%xmm12,%xmm4
+	pcmpeqd		%xmm12,%xmm5
+
+	punpckldq	%xmm4,%xmm4
+	punpckldq	%xmm5,%xmm5
+
+	movapd		 %xmm4,p_region(%rsp)
+	movapd		 %xmm5,p_region1(%rsp)
+
+	mov 	.L__reald_one_zero(%rip),%rdx		#compare value for cossin path
+	mov 	%r8,%r10
+	mov 	%r9,%r11
+
+	shr	$1,%r10						#~AB+A~B, A is sign and B is upper bit of region
+	shr	$1,%r11						#~AB+A~B, A is sign and B is upper bit of region
+
+	mov	%r10,%rax
+	mov	%r11,%rcx
+
+	not 	%r12						#ADDED TO CHANGE THE LOGIC
+	not 	%r13						#ADDED TO CHANGE THE LOGIC
+	and	%r12,%r10
+	and	%r13,%r11
+
+	not	%rax
+	not	%rcx
+	not	%r12
+	not	%r13
+	and	%r12,%rax
+	and	%r13,%rcx
+
+	or	%rax,%r10
+	or	%rcx,%r11
+	and	.L__reald_one_one(%rip),%r10				#(~AB+A~B)&1
+	and	.L__reald_one_one(%rip),%r11				#(~AB+A~B)&1
+
+	mov	%r10,%r12
+	mov	%r11,%r13
+
+	and	%rdx,%r12				#mask out the lower sign bit leaving the upper sign bit
+	and	%rdx,%r13				#mask out the lower sign bit leaving the upper sign bit
+
+	shl	$63,%r10				#shift lower sign bit left by 63 bits
+	shl	$63,%r11				#shift lower sign bit left by 63 bits
+	shl	$31,%r12				#shift upper sign bit left by 31 bits
+	shl	$31,%r13				#shift upper sign bit left by 31 bits
+
+	mov 	 %r10,p_signs(%rsp)		#write out lower sign bit
+	mov 	 %r12,p_signs+8(%rsp)		#write out upper sign bit
+	mov 	 %r11,p_signs1(%rsp)		#write out lower sign bit
+	mov 	 %r13,p_signs1+8(%rsp)		#write out upper sign bit
+
+	movapd	%xmm0,%xmm2				# r
+	movapd	%xmm1,%xmm3				# r
+
+	mulpd	%xmm0,%xmm2				# r2
+	mulpd	%xmm1,%xmm3				# r2
+
+	add	.L__reald_one_one(%rip),%r8
+	add	.L__reald_one_one(%rip),%r9
+
+	and	.L__reald_two_two(%rip),%r8
+	and	.L__reald_two_two(%rip),%r9
+
+	shr	$1,%r8
+	shr	$1,%r9
+
+	mov	%r8,%rax
+	mov	%r9,%rcx
+
+	and	.L__reald_one_zero(%rip),%rax	#mask out the lower sign bit leaving the upper sign bit
+	and	.L__reald_one_zero(%rip),%rcx	#mask out the lower sign bit leaving the upper sign bit
+
+	shl	$63,%r8				#shift lower sign bit left by 63 bits
+	shl	$63,%r9				#shift lower sign bit left by 63 bits
+
+	shl	$31,%rax				#shift upper sign bit left by 31 bits
+	shl	$31,%rcx				#shift upper sign bit left by 31 bits
+
+	mov 	 %r8,p_signc(%rsp)		#write out lower sign bit
+	mov 	 %rax,p_signc+8(%rsp)		#write out upper sign bit
+	mov 	 %r9,p_signc1(%rsp)		#write out lower sign bit
+	mov 	 %rcx,p_signc1+8(%rsp)		#write out upper sign bit
+
+	jmp 	.Lsinsin_sinsin_piby4
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrd4_sin_cleanup:
+
+	xorpd	 p_signs(%rsp),%xmm4		# (+) Sign
+	xorpd	 p_signs1(%rsp),%xmm5		# (+) Sign
+
+	xorpd	 p_signc(%rsp),%xmm12		# (+) Sign
+	xorpd	 p_signc1(%rsp),%xmm13		# (+) Sign
+
+.L__vrda_bottom1:
+# store the result _m128d
+	mov	save_ysa(%rsp),%rdi	# get ysin_array pointer
+	mov	save_yca(%rsp),%rbx	# get ycos_array pointer
+
+	movlpd	 %xmm4,(%rdi)
+	movhpd	 %xmm4,8(%rdi)
+
+	movlpd	 %xmm12,(%rbx)
+	movhpd	 %xmm12,8(%rbx)
+
+.L__vrda_bottom2:
+
+	prefetch	64(%rdi)
+	prefetch	64(%rbx)
+
+	add		$32,%rdi
+	add		$32,%rbx
+
+	mov		%rdi,save_ysa(%rsp)	# save ysin_array pointer
+	mov		%rbx,save_yca(%rsp)	# save ycos_array pointer
+
+# store the result _m128d
+	movlpd	%xmm5, -16(%rdi)
+	movhpd	%xmm5, -8(%rdi)
+
+	movlpd	%xmm13, -16(%rbx)
+	movhpd	%xmm13, -8(%rbx)
+
+	mov	 p_iter(%rsp),%rax	# get number of iterations
+	sub	 $1,%rax
+	mov	 %rax,p_iter(%rsp)	# save number of iterations
+	jnz	.L__vrda_top
+
+# see if we need to do any extras
+	mov	save_nv(%rsp),%rax	# get number of values
+	test	%rax,%rax
+	jnz	.L__vrda_cleanup
+
+.L__final_check:
+
+	mov	save_r12(%rsp),%r12	# restore r12
+	mov	save_r13(%rsp),%r13	# restore r13
+	mov	save_rbx(%rsp),%rbx	# restore rbx
+
+	add	$0x0308,%rsp
+	ret
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# we jump here when we have an odd number of cos calls to make at the end
+# we assume that rdx is pointing at the next x array element, r8 at the next y array element.
+# The number of values left is in save_nv
+
+.align	16
+.L__vrda_cleanup:
+        mov             save_nv(%rsp),%rax      # get number of values
+        test            %rax,%rax               # are there any values
+        jz              .L__final_check         # exit if not
+
+	mov		 save_xa(%rsp),%rsi
+
+# fill in a m128d with zeroes and the extra values and then make a recursive call.
+	xorpd		 %xmm0,%xmm0
+	movlpd		 %xmm0,p_temp+8(%rsp)
+	movapd		 %xmm0,p_temp+16(%rsp)
+
+	mov		 (%rsi),%rcx			# we know there's at least one
+	mov	 	 %rcx,p_temp(%rsp)
+	cmp		 $2,%rax
+	jl		.L__vrdacg
+
+	mov		 8(%rsi),%rcx			# do the second value
+	mov	 	 %rcx,p_temp+8(%rsp)
+	cmp		 $3,%rax
+	jl		.L__vrdacg
+
+	mov		 16(%rsi),%rcx			# do the third value
+	mov	 	 %rcx,p_temp+16(%rsp)
+
+.L__vrdacg:
+	mov		$4,%rdi				# parameter for N
+	lea		p_temp(%rsp),%rsi		# &x parameter
+	lea		p_temp2(%rsp),%rdx 		# &ys parameter
+	lea		p_temp4(%rsp),%rcx 		# &yc parameter
+
+        call    vrda_sincos@PLT # call recursively to compute four values
+
+# now copy the results to the destination array
+	mov		 save_ysa(%rsp),%rdi
+	mov		 save_yca(%rsp),%rbx
+	mov		 save_nv(%rsp),%rax		# get number of values
+
+	mov	 	 p_temp2(%rsp),%rcx
+	mov		 %rcx,(%rdi)			# we know there's at least one
+	mov	 	 p_temp4(%rsp),%rdx
+	mov		 %rdx,(%rbx)			# we know there's at least one
+	cmp		 $2,%rax
+	jl		.L__vrdacgf
+
+	mov	 	 p_temp2+8(%rsp),%rcx
+	mov		 %rcx,8(%rdi)			# do the second value
+	mov	 	 p_temp4+8(%rsp),%rdx
+	mov		 %rdx,8(%rbx)			# do the second value
+	cmp		 $3,%rax
+	jl		.L__vrdacgf
+
+	mov	 	 p_temp2+16(%rsp),%rcx
+	mov		 %rcx,16(%rdi)			# do the third value
+	mov	 	 p_temp4+16(%rsp),%rdx
+	mov		 %rdx,16(%rbx)			# do the third value
+
+.L__vrdacgf:
+	jmp		.L__final_check
diff --git a/src/gas/vrs4cosf.S b/src/gas/vrs4cosf.S
new file mode 100644
index 0000000..ab59058
--- /dev/null
+++ b/src/gas/vrs4cosf.S
@@ -0,0 +1,2122 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrs4_cosf.s
+#
+# A vector implementation of the cosf libm function.
+#
+# Prototype:
+#
+#    __m128 __vrs4_cosf(__m128 x);
+#
+# Computes Cosine of x for an array of input values.
+# Places the results into the supplied y array.
+# Does not perform error checking.
+# Denormal inputs may produce unexpected results.
+# This routine computes 4 single precision Cosine values at a time.
+# The four values are passed as packed single in xmm10.
+# The four results are returned as packed singles in xmm10.
+# Note that this represents a non-standard ABI usage, as no ABI
+# ( and indeed C) currently allows returning 4 values for a function.
+# It is expected that some compilers may be able to take advantage of this
+# interface when implementing vectorized loops.  Using the array implementation
+# of the routine requires putting the inputs into memory, and retrieving
+# the results from memory.  This routine eliminates the need for this
+# overhead if the data does not already reside in memory.
+# Author: Harsha Jagasia
+# Email:  harsha.jagasia@amd.com
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.data
+.align 64
+.L__real_7fffffffffffffff: .quad 0x07fffffffffffffff	#Sign bit zero
+			.quad 0x07fffffffffffffff
+.L__real_3ff0000000000000: .quad 0x03ff0000000000000	# 1.0
+			.quad 0x03ff0000000000000
+.L__real_v2p__27:		.quad 0x03e40000000000000	# 2p-27
+			.quad 0x03e40000000000000
+.L__real_3fe0000000000000: .quad 0x03fe0000000000000	# 0.5
+			.quad 0x03fe0000000000000
+.L__real_3fc5555555555555: .quad 0x03fc5555555555555	# 0.166666666666
+			.quad 0x03fc5555555555555
+.L__real_3fe45f306dc9c883: .quad 0x03fe45f306dc9c883	# twobypi
+			.quad 0x03fe45f306dc9c883
+.L__real_3ff921fb54400000: .quad 0x03ff921fb54400000	# piby2_1
+			.quad 0x03ff921fb54400000
+.L__real_3dd0b4611a626331: .quad 0x03dd0b4611a626331	# piby2_1tail
+			.quad 0x03dd0b4611a626331
+.L__real_3dd0b4611a600000: .quad 0x03dd0b4611a600000	# piby2_2
+			.quad 0x03dd0b4611a600000
+.L__real_3ba3198a2e037073: .quad 0x03ba3198a2e037073	# piby2_2tail
+			.quad 0x03ba3198a2e037073
+.L__real_fffffffff8000000: .quad 0x0fffffffff8000000	# mask for stripping head and tail
+			.quad 0x0fffffffff8000000
+.L__real_8000000000000000:	.quad 0x08000000000000000	# -0  or signbit
+			.quad 0x08000000000000000
+.L__reald_one_one:		.quad 0x00000000100000001	#
+			.quad 0
+.L__reald_two_two:		.quad 0x00000000200000002	#
+			.quad 0
+.L__reald_one_zero:	.quad 0x00000000100000000	# sin_cos_filter
+			.quad 0
+.L__reald_zero_one:	.quad 0x00000000000000001	#
+			.quad 0
+.L__reald_two_zero:	.quad 0x00000000200000000	#
+			.quad 0
+.L__realq_one_one:		.quad 0x00000000000000001	#
+			.quad 0x00000000000000001	#
+.L__realq_two_two:		.quad 0x00000000000000002	#
+			.quad 0x00000000000000002	#
+.L__real_1_x_mask:		.quad 0x0ffffffffffffffff	#
+			.quad 0x03ff0000000000000	#
+.L__real_zero:		.quad 0x00000000000000000	#
+			.quad 0x00000000000000000	#
+.L__real_one:		.quad 0x00000000000000001	#
+			.quad 0x00000000000000001	#
+
+.Lcosarray:
+	.quad	0x03FA5555555502F31		#  0.0416667			c1
+	.quad	0x03FA5555555502F31
+	.quad	0x0BF56C16BF55699D7		# -0.00138889			c2
+	.quad	0x0BF56C16BF55699D7
+	.quad	0x03EFA015C50A93B49		#  2.48016e-005			c3
+	.quad	0x03EFA015C50A93B49
+	.quad	0x0BE92524743CC46B8		# -2.75573e-007			c4
+	.quad	0x0BE92524743CC46B8
+
+.Lsinarray:
+	.quad	0x0BFC555555545E87D		# -0.166667	   		s1
+	.quad	0x0BFC555555545E87D
+	.quad	0x03F811110DF01232D		# 0.00833333	   		s2
+	.quad	0x03F811110DF01232D
+	.quad	0x0BF2A013A88A37196		# -0.000198413			s3
+	.quad	0x0BF2A013A88A37196
+	.quad	0x03EC6DBE4AD1572D5		# 2.75573e-006			s4
+	.quad	0x03EC6DBE4AD1572D5
+
+.Lsincosarray:
+	.quad	0x0BFC555555545E87D		# -0.166667	   		s1
+	.quad	0x03FA5555555502F31		# 0.0416667		   	c1
+	.quad	0x03F811110DF01232D		# 0.00833333	   		s2
+	.quad	0x0BF56C16BF55699D7
+	.quad	0x0BF2A013A88A37196		# -0.000198413			s3
+	.quad	0x03EFA015C50A93B49
+	.quad	0x03EC6DBE4AD1572D5		# 2.75573e-006			s4
+	.quad	0x0BE92524743CC46B8
+
+.Lcossinarray:
+	.quad	0x03FA5555555502F31		# 0.0416667		   	c1
+	.quad	0x0BFC555555545E87D		# -0.166667	   		s1
+	.quad	0x0BF56C16BF55699D7		#				c2
+	.quad	0x03F811110DF01232D
+	.quad	0x03EFA015C50A93B49		#				c3
+	.quad	0x0BF2A013A88A37196
+	.quad	0x0BE92524743CC46B8		#				c4
+	.quad	0x03EC6DBE4AD1572D5
+
+
+.align 64
+.Levencos_oddsin_tbl:
+
+		.quad	.Lcoscos_coscos_piby4		# 0		*	; Done
+		.quad	.Lcoscos_cossin_piby4		# 1		+	; Done
+		.quad	.Lcoscos_sincos_piby4		# 2			; Done
+		.quad	.Lcoscos_sinsin_piby4		# 3		+	; Done
+
+		.quad	.Lcossin_coscos_piby4		# 4			; Done
+		.quad	.Lcossin_cossin_piby4		# 5		*	; Done
+		.quad	.Lcossin_sincos_piby4		# 6			; Done
+		.quad	.Lcossin_sinsin_piby4		# 7			; Done
+
+		.quad	.Lsincos_coscos_piby4		# 8			; Done
+		.quad	.Lsincos_cossin_piby4		# 9			; TBD
+		.quad	.Lsincos_sincos_piby4		# 10		*	; Done
+		.quad	.Lsincos_sinsin_piby4		# 11			; Done
+
+		.quad	.Lsinsin_coscos_piby4		# 12			; Done
+		.quad	.Lsinsin_cossin_piby4		# 13		+	; Done
+		.quad	.Lsinsin_sincos_piby4		# 14			; Done
+		.quad	.Lsinsin_sinsin_piby4		# 15		*	; Done
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    .text
+    .align 16
+    .p2align 4,,15
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# define local variable storage offsets
+.equ	p_temp,0		# temporary for get/put bits operation
+.equ	p_temp1,0x10		# temporary for get/put bits operation
+
+.equ	save_xmm6,0x20		# temporary for get/put bits operation
+.equ	save_xmm7,0x30		# temporary for get/put bits operation
+.equ	save_xmm8,0x40		# temporary for get/put bits operation
+.equ	save_xmm9,0x50		# temporary for get/put bits operation
+.equ	save_xmm0,0x60		# temporary for get/put bits operation
+.equ	save_xmm11,0x70		# temporary for get/put bits operation
+.equ	save_xmm12,0x80		# temporary for get/put bits operation
+.equ	save_xmm13,0x90		# temporary for get/put bits operation
+.equ	save_xmm14,0x0A0	# temporary for get/put bits operation
+.equ	save_xmm15,0x0B0	# temporary for get/put bits operation
+
+.equ	r,0x0C0			# pointer to r for remainder_piby2
+.equ	rr,0x0D0		# pointer to r for remainder_piby2
+.equ	region,0x0E0		# pointer to r for remainder_piby2
+
+.equ	r1,0x0F0		# pointer to r for remainder_piby2
+.equ	rr1,0x0100		# pointer to r for remainder_piby2
+.equ	region1,0x0110		# pointer to r for remainder_piby2
+
+.equ	p_temp2,0x0120		# temporary for get/put bits operation
+.equ	p_temp3,0x0130		# temporary for get/put bits operation
+
+.equ	p_temp4,0x0140		# temporary for get/put bits operation
+.equ	p_temp5,0x0150		# temporary for get/put bits operation
+
+.equ	p_original,0x0160		# original x
+.equ	p_mask,0x0170		# original x
+.equ	p_sign,0x0180		# original x
+
+.equ	p_original1,0x0190		# original x
+.equ	p_mask1,0x01A0		# original x
+.equ	p_sign1,0x01B0		# original x
+
+
+.equ	save_r12,0x01C0		# temporary for get/put bits operation
+.equ	save_r13,0x01D0		# temporary for get/put bits operation
+
+
+.globl __vrs4_cosf
+    .type   __vrs4_cosf,@function
+__vrs4_cosf:
+	sub		$0x01E8,%rsp
+
+#DEBUG
+#	mov	%r12,save_r12(%rsp)	# save r12
+#	mov	%r13,save_r13(%rsp)	# save r13
+
+#	mov	save_r12(%rsp),%r12	# restore r12
+#	mov	save_r13(%rsp),%r13	# restore r13
+
+#	add	$0x01E8,%rsp
+#	ret
+#DEBUG
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	mov	%r12,save_r12(%rsp)	# save r12
+	mov	%r13,save_r13(%rsp)	# save r13
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#STARTMAIN
+
+	movhlps		%xmm0,%xmm8
+	cvtps2pd	%xmm0,%xmm10			# convert input to double.
+	cvtps2pd	%xmm8,%xmm1			# convert input to double.
+
+movdqa	%xmm10,%xmm6
+movdqa	%xmm1,%xmm7
+movapd	.L__real_7fffffffffffffff(%rip),%xmm2
+
+andpd 	%xmm2,%xmm10	#Unsign
+andpd 	%xmm2,%xmm1	#Unsign
+
+movd	%xmm10,%rax				#rax is lower arg
+movhpd	%xmm10, p_temp+8(%rsp)			#
+mov    	p_temp+8(%rsp),%rcx			#rcx = upper arg
+
+movd	%xmm1,%r8				#r8 is lower arg
+movhpd	%xmm1, p_temp1+8(%rsp)			#
+mov    	p_temp1+8(%rsp),%r9			#r9 = upper arg
+
+movdqa	%xmm10,%xmm12
+movdqa	%xmm1,%xmm13
+
+pcmpgtd		%xmm6,%xmm12
+pcmpgtd		%xmm7,%xmm13
+movdqa		%xmm12,%xmm6
+movdqa		%xmm13,%xmm7
+psrldq		$4,%xmm12
+psrldq		$4,%xmm13
+psrldq		$8,%xmm6
+psrldq		$8,%xmm7
+
+mov 	$0x3FE921FB54442D18,%rdx			#piby4	+
+mov	$0x411E848000000000,%r10			#5e5	+
+movapd	.L__real_3fe0000000000000(%rip),%xmm4		#0.5 for later use +
+
+por	%xmm6,%xmm12
+por	%xmm7,%xmm13
+
+movapd	%xmm10,%xmm2				#x0
+movapd	%xmm1,%xmm3				#x1
+movapd	%xmm10,%xmm6				#x0
+movapd	%xmm1,%xmm7				#x1
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm2 = x, xmm4 =0.5/t, xmm6 =x
+# xmm3 = x, xmm5 =0.5/t, xmm7 =x
+.align 16
+.Leither_or_both_arg_gt_than_piby4:
+	cmp	%r10,%rax
+	jae	.Lfirst_or_next3_arg_gt_5e5
+
+	cmp	%r10,%rcx
+	jae	.Lsecond_or_next2_arg_gt_5e5
+
+	cmp	%r10,%r8
+	jae	.Lthird_or_fourth_arg_gt_5e5
+
+	cmp	%r10,%r9
+	jae	.Lfourth_arg_gt_5e5
+
+
+#      /* Find out what multiple of piby2 */
+#        npi2  = (int)(x * twobypi + 0.5);
+	movapd	.L__real_3fe45f306dc9c883(%rip),%xmm10
+	mulpd	%xmm10,%xmm2						# * twobypi
+	mulpd	%xmm10,%xmm3						# * twobypi
+
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	addpd	%xmm4,%xmm3						# +0.5, npi2
+
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm10		# piby2_1
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm1		# piby2_1
+
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	cvttpd2dq	%xmm3,%xmm5					# convert packed double to packed integers
+
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm9		# piby2_2
+
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+	cvtdq2pd	%xmm5,%xmm3					# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+
+	movd	%xmm4,%r8						# Region
+	movd	%xmm5,%r9						# Region
+
+	mov 	.L__reald_one_zero(%rip),%rdx			#compare value for cossin path
+	mov	%r8,%r10
+	mov	%r9,%r11
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm10						# npi2 * piby2_1;
+       mulpd	%xmm3,%xmm1						# npi2 * piby2_1;
+
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+       mulpd	%xmm3,%xmm9						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm10,%xmm6						# rhead  = x - npi2 * piby2_1;
+       subpd	%xmm1,%xmm7						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm10						# t
+       movapd	%xmm7,%xmm1						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm10						# rhead
+       subpd	%xmm9,%xmm1						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm3		# npi2 * piby2_2tail
+
+       subpd	%xmm10,%xmm6						# t-rhead
+       subpd	%xmm1,%xmm7						# t-rhead
+
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       subpd	%xmm7,%xmm9						# - ((t - rhead) - rtail)
+
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       addpd	%xmm3,%xmm9						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm4  = npi2 (int), xmm10 =rhead, xmm8 =rtail, r8 = region, r10 = region, r12 = Sign
+# xmm5  = npi2 (int), xmm1 =rhead, xmm9 =rtail,  r9 = region, r11 = region, r13 = Sign
+
+	and	.L__reald_one_one(%rip),%r8		#odd/even region for cos/sin
+	and	.L__reald_one_one(%rip),%r9		#odd/even region for cos/sin
+
+
+	mov	%r10,%rax
+	mov	%r11,%rcx
+
+	shr	$1,%r10						#~AB+A~B, A is sign and B is upper bit of region
+	shr	$1,%r11						#~AB+A~B, A is sign and B is upper bit of region
+
+	xor	%rax,%r10
+	xor	%rcx,%r11
+	and	.L__reald_one_one(%rip),%r10				#(~AB+A~B)&1
+	and	.L__reald_one_one(%rip),%r11				#(~AB+A~B)&1
+
+	mov	%r10,%r12
+	mov	%r11,%r13
+
+	and	%rdx,%r12				#mask out the lower sign bit leaving the upper sign bit
+	and	%rdx,%r13				#mask out the lower sign bit leaving the upper sign bit
+
+	shl	$63,%r10				#shift lower sign bit left by 63 bits
+	shl	$63,%r11				#shift lower sign bit left by 63 bits
+	shl	$31,%r12				#shift upper sign bit left by 31 bits
+	shl	$31,%r13				#shift upper sign bit left by 31 bits
+
+	mov 	 %r10,p_sign(%rsp)		#write out lower sign bit
+	mov 	 %r12,p_sign+8(%rsp)		#write out upper sign bit
+	mov 	 %r11,p_sign1(%rsp)		#write out lower sign bit
+	mov 	 %r13,p_sign1+8(%rsp)		#write out upper sign bit
+
+
+# GET_BITS_DP64(rhead-rtail, uy);			   		; originally only rhead
+# xmm4  = Sign, xmm10 =rhead, xmm8 =rtail
+# xmm5  = Sign, xmm1  =rhead, xmm9 =rtail
+	movapd	%xmm10,%xmm6						# rhead
+	movapd	%xmm1,%xmm7						# rhead
+
+	subpd	%xmm8,%xmm10						# r = rhead - rtail
+	subpd	%xmm9,%xmm1						# r = rhead - rtail
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm4  = Sign, xmm10 = r, xmm6 =rhead, xmm8 =rtail
+# xmm5  = Sign, xmm1 = r, xmm7 =rhead, xmm9 =rtail
+
+	mov	%r8,%rax
+	mov	%r9,%rcx
+
+	movapd	%xmm10,%xmm2				# move r for r2
+	movapd	%xmm1,%xmm3				# move r for r2
+
+	mulpd	%xmm10,%xmm2				# r2
+	mulpd	%xmm1,%xmm3				# r2
+
+	and	.L__reald_zero_one(%rip),%rax
+	and	.L__reald_zero_one(%rip),%rcx
+	shr	$31,%r8
+	shr	$31,%r9
+	or	%r8,%rax
+	or	%r9,%rcx
+	shl	$2,%rcx
+	or	%rcx,%rax
+
+	leaq	.Levencos_oddsin_tbl(%rip),%rcx
+	jmp	*(%rcx,%rax,8)				#Jmp table for cos/sin calculation based on even/odd region
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lfirst_or_next3_arg_gt_5e5:
+# %rcx,,%rax r8, r9
+
+	cmp	%r10,%rcx				#is upper arg >= 5e5
+	jae	.Lboth_arg_gt_5e5
+
+.Llower_arg_gt_5e5:
+# Upper Arg is < 5e5, Lower arg is >= 5e5
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+# Be sure not to use %xmm3,%xmm1 and xmm7
+# Use %xmm8,,%xmm5 xmm0, xmm12
+#	    %xmm11,,%xmm9 xmm13
+
+
+	movlpd	%xmm10,r(%rsp)		#Save lower fp arg for remainder_piby2 call
+	movhlps	%xmm10,%xmm10		#Needed since we want to work on upper arg
+	movhlps	%xmm2,%xmm2
+	movhlps	%xmm6,%xmm6
+
+# Work on Upper arg
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm4,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm8		# xmm8 = piby2_1
+	cvttsd2si	%xmm2,%ecx				# ecx = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm0		# xmm0 = piby2_2
+	cvtsi2sd	%ecx,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm8					# npi2 * piby2_1
+	subsd	%xmm8,%xmm6					# xmm6 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm12		# xmm12 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm6,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm0					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm0,%xmm6					# xmm6 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm12     					# npi2 * piby2_2tail
+       subsd	%xmm6,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm0					# (rtail-(t-rhead))
+       addsd	%xmm12,%xmm0					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	%ecx,region+4(%rsp)			# store upper region
+       movsd	%xmm6,%xmm10
+       subsd	%xmm0,%xmm10					# xmm10 = r=(rhead-rtail)
+       subsd	%xmm10,%xmm6					# rr=rhead-r
+       subsd	%xmm0,%xmm6					# xmm6 = rr=((rhead-r) -rtail)
+       movlpd	%xmm10,r+8(%rsp)			# store upper r
+       movlpd	%xmm6,rr+8(%rsp)			# store upper rr
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#Note that volatiles will be trashed by the call
+#We will construct r, rr, region and sign
+
+# Work on Lower arg
+	mov		$0x07ff0000000000000,%r11			# is lower arg nan/inf
+	mov		%r11,%r10
+	and		%rax,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_cosf_lower_naninf
+
+	mov	  %r8,p_temp(%rsp)
+	mov	  %r9,p_temp2(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region(%rsp),%rdx			# lower arg is **NOT** nan/inf
+	lea	 r(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	mov	 r(%rsp),%rdi			#Restore lower fp arg for remainder_piby2 call
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	 p_temp(%rsp),%r8
+	mov	 p_temp2(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+	jmp 	0f
+
+.L__vrs4_cosf_lower_naninf:
+	mov	 $0x00008000000000000,%r11
+	or	 %r11,%rax
+	mov	 %rax,r(%rsp)				# r = x | 0x0008000000000000
+	mov	 %r10d,region(%rsp)			# region =0
+
+.align 16
+0:
+	jmp .Lcheck_next2_args
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lboth_arg_gt_5e5:
+#Upper Arg is >= 5e5, Lower arg is >= 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+
+	movhlps %xmm10,%xmm6		#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r11			#is lower arg nan/inf
+	mov		%r11,%r10
+	and		%rax,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_cosf_lower_naninf_of_both_gt_5e5
+
+	mov	  %rcx,p_temp(%rsp)			#Save upper arg
+	mov	  %r8,p_temp2(%rsp)
+	mov	  %r9,p_temp4(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	 r(%rsp),%rsi
+
+# added ins- changed input from xmm10 to xmm0
+	movd	%xmm10,%rdi
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	 p_temp2(%rsp),%r8
+	mov	 p_temp4(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+
+	mov	 p_temp(%rsp),%rcx			#Restore upper arg
+	jmp 	0f
+
+.L__vrs4_cosf_lower_naninf_of_both_gt_5e5:				#lower arg is nan/inf
+	mov	 $0x00008000000000000,%r11
+	or	 %r11,%rax
+	mov	 %rax,r(%rsp)				#r = x | 0x0008000000000000
+	mov	 %r10d,region(%rsp)			#region = 0
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r11			#is upper arg nan/inf
+	mov		%r11,%r10
+	and		%rcx,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_cosf_upper_naninf_of_both_gt_5e5
+
+
+	mov	  %r8,p_temp2(%rsp)
+	mov	  %r9,p_temp4(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region+4(%rsp),%rdx			#upper arg is **NOT** nan/inf
+	lea	 r+8(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	movd	 %xmm6,%rdi			#Restore upper fp arg for remainder_piby2 call
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	 p_temp2(%rsp),%r8
+	mov	 p_temp4(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+
+	jmp 	0f
+
+.L__vrs4_cosf_upper_naninf_of_both_gt_5e5:
+	mov	 $0x00008000000000000,%r11
+	or	 %r11,%rcx
+	mov	 %rcx,r+8(%rsp)				#r = x | 0x0008000000000000
+	mov	 %r10d,region+4(%rsp)			#region = 0
+
+.align 16
+0:
+	jmp .Lcheck_next2_args
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lsecond_or_next2_arg_gt_5e5:
+
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+# Do not use %xmm3,,%xmm1 xmm7
+# Restore xmm4 and %xmm3,,%xmm1 xmm7
+# Can use %xmm0,,%xmm8 xmm12
+#   %xmm9,,%xmm5 xmm11, xmm13
+
+	movhpd	 %xmm10,r+8(%rsp)	#Save upper fp arg for remainder_piby2 call
+
+# Work on Lower arg
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm4,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm8		# xmm3 = piby2_1
+	cvttsd2si	%xmm2,%eax				# ecx = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm0		# xmm1 = piby2_2
+	cvtsi2sd	%eax,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm8					# npi2 * piby2_1
+	subsd	%xmm8,%xmm6					# xmm6 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm12		# xmm7 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm6,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm0					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm0,%xmm6					# xmm6 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm12     					# npi2 * piby2_2tail
+       subsd	%xmm6,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm0					# (rtail-(t-rhead))
+       addsd	%xmm12,%xmm0					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %eax,region(%rsp)			# store upper region
+
+        subsd	%xmm0,%xmm6					# xmm10 = r=(rhead-rtail)
+
+        movlpd	 %xmm6,r(%rsp)				# store upper r
+
+
+#Work on Upper arg
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+	mov		$0x07ff0000000000000,%r11			# is upper arg nan/inf
+	mov		%r11,%r10
+	and		%rcx,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_cosf_upper_naninf
+
+	mov	 %r8,p_temp(%rsp)
+	mov	 %r9,p_temp2(%rsp)
+	movapd	 %xmm1,p_temp1(%rsp)
+	movapd	 %xmm3,p_temp3(%rsp)
+	movapd	 %xmm7,p_temp5(%rsp)
+
+	lea	 region+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 r+8(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	mov	 r+8(%rsp),%rdi				#Restore upper fp arg for remainder_piby2 call
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	p_temp(%rsp),%r8
+	mov	p_temp2(%rsp),%r9
+	movapd	p_temp1(%rsp),%xmm1
+	movapd	p_temp3(%rsp),%xmm3
+	movapd	p_temp5(%rsp),%xmm7
+	jmp 	0f
+
+.L__vrs4_cosf_upper_naninf:
+	mov	 $0x00008000000000000,%r11
+	or	 %r11,%rcx
+	mov	 %rcx,r+8(%rsp)				# r = x | 0x0008000000000000
+	mov	 %r10d,region+4(%rsp)			# region =0
+
+.align 16
+0:
+	jmp 	.Lcheck_next2_args
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcheck_next2_args:
+
+	mov	$0x411E848000000000,%r10			#5e5	+
+
+	cmp	%r10,%r8
+	jae	.Lfirst_second_done_third_or_fourth_arg_gt_5e5
+
+	cmp	%r10,%r9
+	jae	.Lfirst_second_done_fourth_arg_gt_5e5
+
+
+
+# Work on next two args, both < 5e5
+# %xmm3,,%xmm1 xmm5 = x, xmm4 = 0.5
+
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4			#Restore 0.5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm3						# * twobypi
+	addpd	%xmm4,%xmm3						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm1		# piby2_1
+	cvttpd2dq	%xmm3,%xmm5					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm9		# piby2_2
+	cvtdq2pd	%xmm5,%xmm3					# and back to double.
+
+###
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movlpd	 %xmm5,region1(%rsp)						# Region
+###
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm3,%xmm1						# npi2 * piby2_1;
+
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm3,%xmm9						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm1,%xmm7						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm7,%xmm1						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm9,%xmm1						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm3		# npi2 * piby2_2tail
+
+       subpd	%xmm1,%xmm7						# t-rhead
+       subpd	%xmm7,%xmm9						# - ((t - rhead) - rtail)
+       addpd	%xmm3,%xmm9						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+       subpd	%xmm9,%xmm1						# r = rhead - rtail
+       movapd	%xmm1,r1(%rsp)
+
+       jmp	.L__vrs4_cosf_reconstruct
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lthird_or_fourth_arg_gt_5e5:
+#first two args are < 5e5, third arg >= 5e5, fourth arg >= 5e5 or < 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+# Do not use %xmm3,,%xmm1 xmm7
+# Can use 	%xmm11,,%xmm9 xmm13
+# 	%xmm8,,%xmm5 xmm0, xmm12
+# Restore xmm4
+
+# Work on first two args, both < 5e5
+
+
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# * twobypi
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm10		# piby2_1
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+
+###
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movlpd	 %xmm4,region(%rsp)				# Region
+###
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm10						# npi2 * piby2_1;
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm10,%xmm6						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm10						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm10						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+
+       subpd	%xmm10,%xmm6						# t-rhead
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+       subpd	%xmm8,%xmm10						# r = rhead - rtail
+       movapd	%xmm10,r(%rsp)
+
+# Work on next two args, third arg >= 5e5, fourth arg >= 5e5 or < 5e5
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lfirst_second_done_third_or_fourth_arg_gt_5e5:
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+
+
+	mov	$0x411E848000000000,%r10			#5e5	+
+	cmp	%r10,%r9
+	jae	.Lboth_arg_gt_5e5_higher
+
+
+# Upper Arg is <5e5, Lower arg is >= 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+	movlpd	 %xmm1,r1(%rsp)		#Save lower fp arg for remainder_piby2 call
+	movhlps	%xmm1,%xmm1			#Needed since we want to work on upper arg
+	movhlps	%xmm3,%xmm3
+	movhlps	%xmm7,%xmm7
+
+
+# Work on Upper arg
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4		# Restore 0.5
+
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm3		# x*twobypi
+	addsd	%xmm4,%xmm3					# xmm3 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm2		# xmm2 = piby2_1
+	cvttsd2si	%xmm3,%r9d				# r9d = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm10		# xmm10 = piby2_2
+	cvtsi2sd	%r9d,%xmm3				# xmm3 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm3,%xmm2					# npi2 * piby2_1
+	subsd	%xmm2,%xmm7					# xmm7 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm7,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm3,%xmm10					# xmm10 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm10,%xmm7					# xmm7 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm3,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm7,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm10					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm10					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %r9d,region1+4(%rsp)			# store upper region
+
+       subsd	%xmm10,%xmm7					# xmm1 = r=(rhead-rtail)
+
+       movlpd	 %xmm7,r1+8(%rsp)			# store upper r
+
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+
+# Work on Lower arg
+	mov		$0x07ff0000000000000,%r11			# is lower arg nan/inf
+	mov		%r11,%r10
+	and		%r8,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_cosf_lower_naninf_higher
+
+	lea	 region1(%rsp),%rdx			# lower arg is **NOT** nan/inf
+	lea	 r1(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	mov	 r1(%rsp),%rdi				#Restore lower fp arg for remainder_piby2 call
+
+	call	 __remainder_piby2d2f@PLT
+
+	jmp 	0f
+
+.L__vrs4_cosf_lower_naninf_higher:
+	mov	 $0x00008000000000000,%r11
+	or	 %r11,%r8
+	mov	 %r8,r1(%rsp)				# r = x | 0x0008000000000000
+	mov	 %r10d,region1(%rsp)			# region =0
+
+.align 16
+0:
+	jmp 	.L__vrs4_cosf_reconstruct
+
+
+
+
+
+
+
+.align 16
+.Lboth_arg_gt_5e5_higher:
+# Upper Arg is >= 5e5, Lower arg is >= 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+
+	movhlps %xmm1,%xmm7		#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r11			#is lower arg nan/inf
+	mov		%r11,%r10
+	and		%r8,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_cosf_lower_naninf_of_both_gt_5e5_higher
+
+	mov	  %r9,p_temp1(%rsp)			#Save upper arg
+	lea	  region1(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	  r1(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	movd	 %xmm1,%rdi
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	 p_temp1(%rsp),%r9			#Restore upper arg
+
+	jmp 	0f
+
+.L__vrs4_cosf_lower_naninf_of_both_gt_5e5_higher:				#lower arg is nan/inf
+	mov	 $0x00008000000000000,%r11
+	or	 %r11,%r8
+	mov	 %r8,r1(%rsp)				#r = x | 0x0008000000000000
+	mov	 %r10d,region1(%rsp)			#region = 0
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r11			#is upper arg nan/inf
+	mov		%r11,%r10
+	and		%r9,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_cosf_upper_naninf_of_both_gt_5e5_higher
+
+	lea	 region1+4(%rsp),%rdx			#upper arg is **NOT** nan/inf
+	lea	 r1+8(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	movd	 %xmm7,%rdi			#Restore upper fp arg for remainder_piby2 call
+
+	call	 __remainder_piby2d2f@PLT
+
+	jmp 	0f
+
+.L__vrs4_cosf_upper_naninf_of_both_gt_5e5_higher:
+	mov	 $0x00008000000000000,%r11
+	or	 %r11,%r9
+	mov	 %r9,r1+8(%rsp)				#r = x | 0x0008000000000000
+	mov	 %r10d,region1+4(%rsp)			#region = 0
+
+.align 16
+0:
+
+	jmp 	.L__vrs4_cosf_reconstruct
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lfourth_arg_gt_5e5:
+#first two args are < 5e5, third arg < 5e5, fourth arg >= 5e5
+#%rcx,,%rax r8, r9
+#%xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+
+# Work on first two args, both < 5e5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# * twobypi
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm10		# piby2_1
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+
+###
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movlpd	 %xmm4,region(%rsp)				# Region
+###
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm10						# npi2 * piby2_1;
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm10,%xmm6						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm10						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm10						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+
+       subpd	%xmm10,%xmm6						# t-rhead
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+       subpd	%xmm8,%xmm10						# r = rhead - rtail
+       movapd	 %xmm10,r(%rsp)
+
+# Work on next two args, third arg < 5e5, fourth arg >= 5e5
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lfirst_second_done_fourth_arg_gt_5e5:
+
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+	movhpd	 %xmm1,r1+8(%rsp)	#Save upper fp arg for remainder_piby2 call
+
+# Work on Lower arg
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4		# Restore 0.5
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm3		# x*twobypi
+	addsd	%xmm4,%xmm3					# xmm3 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm2		# xmm2 = piby2_1
+	cvttsd2si	%xmm3,%r8d				# r8d = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm10		# xmm10 = piby2_2
+	cvtsi2sd	%r8d,%xmm3				# xmm3 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm3,%xmm2					# npi2 * piby2_1
+	subsd	%xmm2,%xmm7					# xmm7 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm7,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm3,%xmm10					# xmm10 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm10,%xmm7					# xmm7 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm3,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm7,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm10					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm10					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+        mov	 %r8d,region1(%rsp)			# store lower region
+
+        subsd	%xmm10,%xmm7					# xmm10 = r=(rhead-rtail)
+
+        movlpd	 %xmm7,r1(%rsp)				# store upper r
+
+#Work on Upper arg
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+	mov		$0x07ff0000000000000,%r11			# is upper arg nan/inf
+	mov		%r11,%r10
+	and		%r9,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_cosf_upper_naninf_higher
+
+	lea	 region1+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 r1+8(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	mov	 r1+8(%rsp),%rdi	#Restore upper fp arg for remainder_piby2 call
+
+	call	 __remainder_piby2d2f@PLT
+
+	jmp 	0f
+
+.L__vrs4_cosf_upper_naninf_higher:
+	mov	 $0x00008000000000000,%r11
+	or	 %r11,%r9
+	mov	 %r9,r1+8(%rsp)				# r = x | 0x0008000000000000
+	mov	 %r10d,region1+4(%rsp)			# region =0
+
+.align 16
+0:
+	jmp	.L__vrs4_cosf_reconstruct
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrs4_cosf_reconstruct:
+#Results
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	r(%rsp),%xmm10
+	movapd	r1(%rsp),%xmm1
+
+	mov	region(%rsp),%r8
+	mov	region1(%rsp),%r9
+	mov 	.L__reald_one_zero(%rip),%rdx		#compare value for cossin path
+
+	mov 	%r8,%r10
+	mov 	%r9,%r11
+
+	and	.L__reald_one_one(%rip),%r8		#odd/even region for cos/sin
+	and	.L__reald_one_one(%rip),%r9		#odd/even region for cos/sin
+
+	mov	%r10,%rax
+	mov	%r11,%rcx
+
+	shr	$1,%r10						#~AB+A~B, A is sign and B is upper bit of region
+	shr	$1,%r11						#~AB+A~B, A is sign and B is upper bit of region
+
+	xor	%rax,%r10
+	xor	%rcx,%r11
+	and	.L__reald_one_one(%rip),%r10				#(~AB+A~B)&1
+	and	.L__reald_one_one(%rip),%r11				#(~AB+A~B)&1
+
+	mov	%r10,%r12
+	mov	%r11,%r13
+
+	and	%rdx,%r12				#mask out the lower sign bit leaving the upper sign bit
+	and	%rdx,%r13				#mask out the lower sign bit leaving the upper sign bit
+
+	shl	$63,%r10				#shift lower sign bit left by 63 bits
+	shl	$63,%r11				#shift lower sign bit left by 63 bits
+	shl	$31,%r12				#shift upper sign bit left by 31 bits
+	shl	$31,%r13				#shift upper sign bit left by 31 bits
+
+	mov 	 %r10,p_sign(%rsp)		#write out lower sign bit
+	mov 	 %r12,p_sign+8(%rsp)		#write out upper sign bit
+	mov 	 %r11,p_sign1(%rsp)		#write out lower sign bit
+	mov 	 %r13,p_sign1+8(%rsp)		#write out upper sign bit
+
+	mov	%r8,%rax
+	mov	%r9,%rcx
+
+	movapd	%xmm10,%xmm2
+	movapd	%xmm1,%xmm3
+
+	mulpd	%xmm10,%xmm2				# r2
+	mulpd	%xmm1,%xmm3				# r2
+
+	and	.L__reald_zero_one(%rip),%rax
+	and	.L__reald_zero_one(%rip),%rcx
+	shr	$31,%r8
+	shr	$31,%r9
+	or	%r8,%rax
+	or	%r9,%rcx
+	shl	$2,%rcx
+	or	%rcx,%rax
+
+	leaq	.Levencos_oddsin_tbl(%rip),%rcx
+	jmp	*(%rcx,%rax,8)				#Jmp table for cos/sin calculation based on even/odd region
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrs4_cosf_cleanup:
+
+	movapd	  p_sign(%rsp),%xmm10
+	movapd	  p_sign1(%rsp),%xmm1
+
+	xorpd	%xmm4,%xmm10			# (+) Sign
+	xorpd	%xmm5,%xmm1			# (+) Sign
+
+	cvtpd2ps %xmm10,%xmm0
+	cvtpd2ps %xmm1,%xmm11
+	movlhps	 %xmm11,%xmm0
+
+	mov	save_r12(%rsp),%r12	# restore r12
+	mov	save_r13(%rsp),%r13	# restore r13
+
+	add	$0x01E8,%rsp
+	ret
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;JUMP TABLE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcoscos_coscos_piby4:
+	movapd	%xmm2,%xmm0					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lcosarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lcosarray+0x30(%rip),%xmm5			# c4
+
+	movapd	.Lcosarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lcosarray+0x10(%rip),%xmm9			# c2
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm0		# -t=r-1.0	;trash r
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0	;trash r
+
+	mulpd	%xmm2,%xmm2					# x4
+	mulpd	%xmm3,%xmm3					# x4
+
+	addpd	.Lcosarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lcosarray+0x20(%rip),%xmm5			# c3+x2c4
+
+	addpd	.Lcosarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lcosarray(%rip),%xmm9			# c1+x2c2
+
+	mulpd	%xmm2,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm3,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x4 * zc
+
+	subpd   %xmm0,%xmm4					# + t
+	subpd   %xmm11,%xmm5					# + t
+
+	jmp 	.L__vrs4_cosf_cleanup
+
+.align 16
+.Lcossin_cossin_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movdqa	.Lsincosarray+0x30(%rip),%xmm4		# s4
+	movdqa	.Lsincosarray+0x30(%rip),%xmm5		# s4
+	movapd	.Lsincosarray+0x10(%rip),%xmm8		# s2
+	movapd	.Lsincosarray+0x10(%rip),%xmm9		# s2
+
+	movapd	%xmm2,%xmm0				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+
+	mulpd	%xmm2,%xmm4				# x2s4
+	mulpd	%xmm3,%xmm5				# x2s4
+	mulpd	%xmm2,%xmm8				# x2s2
+	mulpd	%xmm3,%xmm9				# x2s2
+
+	mulpd	%xmm2,%xmm0				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lsincosarray+0x20(%rip),%xmm4		# s4+x2s3
+	addpd	.Lsincosarray+0x20(%rip),%xmm5		# s4+x2s3
+	addpd	.Lsincosarray(%rip),%xmm8		# s2+x2s1
+	addpd	.Lsincosarray(%rip),%xmm9		# s2+x2s1
+
+	mulpd	%xmm0,%xmm4				# x4(s3+x2s4)
+	mulpd	%xmm11,%xmm5				# x4(s3+x2s4)
+
+	movhlps	%xmm0,%xmm0				# move high x4 for cos term
+	movhlps	%xmm11,%xmm11				# move high x4 for cos term
+
+	movsd	%xmm2,%xmm6				# move low x2 for x3 for sin term
+	movsd	%xmm3,%xmm7				# move low x2 for x3 for sin term
+	mulsd	%xmm10,%xmm6				# get low x3 for sin term
+	mulsd	%xmm1,%xmm7				# get low x3 for sin term
+
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for sin and cos terms
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for sin and cos terms
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm2,%xmm12				# move high r for cos
+	movhlps	%xmm3,%xmm13				# move high r for cos
+
+	movhlps	%xmm4,%xmm8				# xmm4 = sin , xmm8 = cos
+	movhlps	%xmm5,%xmm9				# xmm4 = sin , xmm8 = cos
+
+	mulsd	%xmm6,%xmm4				# sin *x3
+	mulsd	%xmm7,%xmm5				# sin *x3
+
+	mulsd	%xmm0,%xmm8				# cos *x4
+	mulsd	%xmm11,%xmm9				# cos *x4
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12 	#-t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13 	#-t=r-1.0
+
+	addsd	%xmm10,%xmm4				# sin + x
+	addsd	%xmm1,%xmm5				# sin + x
+	subsd   %xmm12,%xmm8				# cos+t
+	subsd   %xmm13,%xmm9				# cos+t
+
+	movlhps	%xmm8,%xmm4
+	movlhps	%xmm9,%xmm5
+
+	jmp 	.L__vrs4_cosf_cleanup
+
+.align 16
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lsincos_cossin_piby4:
+
+	movapd	.Lsincosarray+0x30(%rip),%xmm4		# s4
+	movapd	.Lcossinarray+0x30(%rip),%xmm5		# s4
+	movdqa	.Lsincosarray+0x10(%rip),%xmm8		# s2
+	movdqa	.Lcossinarray+0x10(%rip),%xmm9		# s2
+
+	movapd	%xmm2,%xmm0				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+	movapd	%xmm3,%xmm7				# sincos term upper x2 for x3
+
+	mulpd	%xmm2,%xmm4				# x2s4
+	mulpd	%xmm3,%xmm5				# x2s4
+	mulpd	%xmm2,%xmm8				# x2s2
+	mulpd	%xmm3,%xmm9				# x2s2
+
+	mulpd	%xmm2,%xmm0				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lsincosarray+0x20(%rip),%xmm4		# s3+x2s4
+	addpd	.Lcossinarray+0x20(%rip),%xmm5		# s3+x2s4
+	addpd	.Lsincosarray(%rip),%xmm8		# s1+x2s2
+	addpd	.Lcossinarray(%rip),%xmm9		# s1+x2s2
+
+	mulpd	%xmm0,%xmm4				# x4(s3+x2s4)
+	mulpd	%xmm11,%xmm5				# x4(s3+x2s4)
+
+	movhlps	%xmm0,%xmm0				# move high x4 for cos term
+
+	movsd	%xmm2,%xmm6				# move low x2 for x3 for sin term  (cossin)
+	mulpd	%xmm1,%xmm7
+
+	mulsd	%xmm10,%xmm6				# get low x3 for sin term (cossin)
+	movhlps	%xmm7,%xmm7				# get high x3 for sin term (sincos)
+
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for cos term
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for cos term
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+
+	movhlps	%xmm2,%xmm12				# move high r for cos (cossin)
+
+
+	movhlps	%xmm4,%xmm8				# xmm8 = cos , xmm4 = sin	(cossin)
+	movhlps	%xmm5,%xmm9				# xmm9 = sin , xmm5 = cos	(sincos)
+
+	mulsd	%xmm6,%xmm4				# sin *x3
+	mulsd	%xmm11,%xmm5				# cos *x4
+	mulsd	%xmm0,%xmm8				# cos *x4
+	mulsd	%xmm7,%xmm9				# sin *x3
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12 	#-t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm3 	# -t=r-1.0
+
+	movhlps	%xmm1,%xmm11				# move high x for x for sin term    (sincos)
+
+	addsd	%xmm10,%xmm4				# sin + x	+
+	addsd	%xmm11,%xmm9				# sin + x	+
+
+	subsd   %xmm12,%xmm8				# cos+t
+	subsd   %xmm3,%xmm5				# cos+t
+
+	movlhps	%xmm8,%xmm4				# cossin
+	movlhps	%xmm9,%xmm5				# sincos
+
+	jmp	.L__vrs4_cosf_cleanup
+
+.align 16
+.Lsincos_sincos_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	.Lcossinarray+0x30(%rip),%xmm4		# s4
+	movapd	.Lcossinarray+0x30(%rip),%xmm5		# s4
+	movdqa	.Lcossinarray+0x10(%rip),%xmm8		# s2
+	movdqa	.Lcossinarray+0x10(%rip),%xmm9		# s2
+
+	movapd	%xmm2,%xmm0				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+	movapd	%xmm2,%xmm6				# move x2 for x4
+	movapd	%xmm3,%xmm7				# move x2 for x4
+
+	mulpd	%xmm2,%xmm4				# x2s6
+	mulpd	%xmm3,%xmm5				# x2s6
+	mulpd	%xmm2,%xmm8				# x2s3
+	mulpd	%xmm3,%xmm9				# x2s3
+
+	mulpd	%xmm2,%xmm0				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lcossinarray+0x20(%rip),%xmm4		# s4+x2s3
+	addpd	.Lcossinarray+0x20(%rip),%xmm5		# s4+x2s3
+	addpd	.Lcossinarray(%rip),%xmm8		# s2+x2s1
+	addpd	.Lcossinarray(%rip),%xmm9		# s2+x2s1
+
+	mulpd	%xmm0,%xmm4				# x4(s4+x2s3)
+	mulpd	%xmm11,%xmm5				# x4(s4+x2s3)
+
+	mulpd	%xmm10,%xmm6				# get low x3 for sin term
+	mulpd	%xmm1,%xmm7				# get low x3 for sin term
+	movhlps	%xmm6,%xmm6				# move low x2 for x3 for sin term
+	movhlps	%xmm7,%xmm7				# move low x2 for x3 for sin term
+
+	mulsd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for cos terms
+	mulsd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for cos terms
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm4,%xmm12				# xmm8 = sin , xmm4 = cos
+	movhlps	%xmm5,%xmm13				# xmm9 = sin , xmm5 = cos
+
+	mulsd	%xmm6,%xmm12				# sin *x3
+	mulsd	%xmm7,%xmm13				# sin *x3
+	mulsd	%xmm0,%xmm4				# cos *x4
+	mulsd	%xmm11,%xmm5				# cos *x4
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm2 	#-t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm3 	#-t=r-1.0
+
+	movhlps	%xmm10,%xmm0				# move high x for x for sin term
+	movhlps	%xmm1,%xmm11				# move high x for x for sin term
+							# Reverse 10 and 0
+
+	addsd	%xmm0,%xmm12				# sin + x
+	addsd	%xmm11,%xmm13				# sin + x
+
+	subsd   %xmm2,%xmm4				# cos+t
+	subsd   %xmm3,%xmm5				# cos+t
+
+	movlhps	%xmm12,%xmm4
+	movlhps	%xmm13,%xmm5
+	jmp 	.L__vrs4_cosf_cleanup
+
+.align 16
+.Lcossin_sincos_piby4:
+
+	movapd	.Lcossinarray+0x30(%rip),%xmm4		# s4
+	movapd	.Lsincosarray+0x30(%rip),%xmm5		# s4
+	movdqa	.Lcossinarray+0x10(%rip),%xmm8		# s2
+	movdqa	.Lsincosarray+0x10(%rip),%xmm9		# s2
+
+	movapd	%xmm2,%xmm0				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+	movapd	%xmm2,%xmm7				# upper x2 for x3 for sin term (sincos)
+
+	mulpd	%xmm2,%xmm4				# x2s4
+	mulpd	%xmm3,%xmm5				# x2s4
+	mulpd	%xmm2,%xmm8				# x2s2
+	mulpd	%xmm3,%xmm9				# x2s2
+
+	mulpd	%xmm2,%xmm0				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lcossinarray+0x20(%rip),%xmm4		# s3+x2s4
+	addpd	.Lsincosarray+0x20(%rip),%xmm5		# s3+x2s4
+	addpd	.Lcossinarray(%rip),%xmm8		# s1+x2s2
+	addpd	.Lsincosarray(%rip),%xmm9		# s1+x2s2
+
+	mulpd	%xmm0,%xmm4				# x4(s3+x2s4)
+	mulpd	%xmm11,%xmm5				# x4(s3+x2s4)
+
+	movhlps	%xmm11,%xmm11				# move high x4 for cos term
+
+	movsd	%xmm3,%xmm6				# move low x2 for x3 for sin term  (cossin)
+	mulpd	%xmm10,%xmm7
+
+	mulsd	%xmm1,%xmm6				# get low x3 for sin term (cossin)
+	movhlps	%xmm7,%xmm7				# get high x3 for sin term (sincos)
+
+	mulsd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for cos term
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for cos term
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm3,%xmm12				# move high r for cos (cossin)
+
+	movhlps	%xmm4,%xmm8				# xmm8 = sin , xmm4 = cos	(sincos)
+	movhlps	%xmm5,%xmm9				# xmm9 = cos , xmm5 = sin	(cossin)
+
+	mulsd	%xmm0,%xmm4				# cos *x4
+	mulsd	%xmm6,%xmm5				# sin *x3
+	mulsd	%xmm7,%xmm8				# sin *x3
+	mulsd	%xmm11,%xmm9				# cos *x4
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm2 	# -t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12 	# -t=r-1.0
+
+	movhlps	%xmm10,%xmm11				# move high x for x for sin term    (sincos)
+
+	subsd	%xmm2,%xmm4				# cos-(-t)
+	subsd	%xmm12,%xmm9				# cos-(-t)
+
+	addsd   %xmm11,%xmm8				# sin + x
+	addsd   %xmm1,%xmm5				# sin + x
+
+	movlhps	%xmm8,%xmm4				# cossin
+	movlhps	%xmm9,%xmm5				# sincos
+
+	jmp	.L__vrs4_cosf_cleanup
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcoscos_sinsin_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr: 	SIN
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr:	COS
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	%xmm2,%xmm0					# x2	; SIN
+	movapd	%xmm3,%xmm11					# x2	; COS
+	movapd	%xmm3,%xmm1					# copy of x2 for x4
+
+	movdqa	.Lsinarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lcosarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lsinarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lcosarray+0x10(%rip),%xmm9			# c2
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11	# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	mulpd	%xmm2,%xmm0					# x4
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11		# -t=r-1.0
+	mulpd	%xmm3,%xmm1					# x4
+
+	addpd	.Lsinarray+0x20(%rip),%xmm4				# c3+x2c4
+	addpd	.Lcosarray+0x20(%rip),%xmm5				# c3+x2c4
+	addpd	.Lsinarray(%rip),%xmm8					# c1+x2c2
+	addpd	.Lcosarray(%rip),%xmm9				# c1+x2c2
+
+	mulpd	%xmm10,%xmm2					# x3
+
+	mulpd	%xmm0,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm1,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm1,%xmm5					# x4 * zc
+
+	addpd	%xmm10,%xmm4					# +x
+	subpd   %xmm11,%xmm5					# +t
+
+	jmp 	.L__vrs4_cosf_cleanup
+
+.align 16
+.Lsinsin_coscos_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr: 	COS
+# p_sign1  = Sign, xmm1  = r, xmm3 = %xmm7,%r2 =rr:	SIN
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	%xmm2,%xmm0					# x2	; COS
+	movapd	%xmm3,%xmm11					# x2	; SIN
+	movapd	%xmm2,%xmm10					# copy of x2 for x4
+
+	movdqa	.Lcosarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lsinarray+0x30(%rip),%xmm5			# s4
+	movapd	.Lcosarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lsinarray+0x10(%rip),%xmm9			# s2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# s4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# s2*x2
+
+	mulpd	%xmm2,%xmm10					# x4
+	mulpd	%xmm3,%xmm11					# x4
+
+	addpd	.Lcosarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lsinarray+0x20(%rip),%xmm5			# s3+x2c4
+	addpd	.Lcosarray(%rip),%xmm8				# c1+x2c2
+	addpd	.Lsinarray(%rip),%xmm9				# s1+x2c2
+
+	mulpd	%xmm1,%xmm3					# x3
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+
+	mulpd	%xmm10,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm11,%xmm5					# x4(s3+x2s4)
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm0		# -t=r-1.0
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zs
+
+	mulpd	%xmm10,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x3 * zc
+
+	subpd	%xmm0,%xmm4					# +t
+	addpd   %xmm1,%xmm5					# +x
+
+	jmp 	.L__vrs4_cosf_cleanup
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcoscos_cossin_piby4:						#Derive from cossin_coscos
+	movhlps	%xmm2,%xmm0					# x2 for 0.5x2 for upper cos
+	movsd	%xmm2,%xmm6					# lower x2 for x3 for lower sin
+	movapd	%xmm3,%xmm11					# x2 for 0.5x2
+	movapd	%xmm2,%xmm12					# x2 for x4
+	movapd	%xmm3,%xmm13					# x2 for x4
+
+	movsd	.L__real_3ff0000000000000(%rip),%xmm7
+
+	movdqa	.Lsincosarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lcosarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lsincosarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lcosarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	subsd	%xmm0,%xmm7					#  t=1.0-r  for cos
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11		# -t=r-1.0
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lsincosarray+0x20(%rip),%xmm4			# c4+x2c3
+	addpd	.Lcosarray+0x20(%rip),%xmm5			# c4+x2c3
+	addpd	.Lsincosarray(%rip),%xmm8			# c2+x2c1
+	addpd	.Lcosarray(%rip),%xmm9				# c2+x2c1
+
+	movapd	%xmm12,%xmm2					# upper=x4
+	movsd	%xmm6,%xmm2					# lower=x2
+	mulsd	%xmm10,%xmm2					# lower=x2*x
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm2,%xmm4					# upper= x4 * zc
+								# lower=x3 * zs
+	mulpd	%xmm13,%xmm5					# x4 * zc
+
+	movlhps	%xmm7,%xmm10					#
+	addpd	%xmm10,%xmm4					# +x for lower sin, +t for upper cos
+	subpd   %xmm11,%xmm5					# -(-t)
+
+	jmp 	.L__vrs4_cosf_cleanup
+
+.align 16
+.Lcoscos_sincos_piby4:					#Derive from cossin_coscos
+	movsd	%xmm2,%xmm0					# x2 for 0.5x2 for lower cos
+	movapd	%xmm3,%xmm11					# x2 for 0.5x2
+	movapd	%xmm2,%xmm12					# x2 for x4
+	movapd	%xmm3,%xmm13					# x2 for x4
+	movsd	.L__real_3ff0000000000000(%rip),%xmm7
+
+	movdqa	.Lcossinarray+0x30(%rip),%xmm4			# cs4
+	movdqa	.Lcosarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lcossinarray+0x10(%rip),%xmm8			# cs2
+	movapd	.Lcosarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	subsd	%xmm0,%xmm7					# t=1.0-r  for cos
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11		# -t=r-1.0
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lcossinarray+0x20(%rip),%xmm4			# c4+x2c3
+	addpd	.Lcosarray+0x20(%rip),%xmm5			# c4+x2c3
+	addpd	.Lcossinarray(%rip),%xmm8			# c2+x2c1
+	addpd	.Lcosarray(%rip),%xmm9				# c2+x2c1
+
+	mulpd	%xmm10,%xmm2					# upper=x3 for sin
+	mulsd	%xmm10,%xmm2					# lower=x4 for cos
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm2,%xmm4					# lower= x4 * zc
+								# upper= x3 * zs
+	mulpd	%xmm13,%xmm5					# x4 * zc
+
+	movsd	%xmm7,%xmm10
+	addpd	%xmm10,%xmm4					# +x for upper sin, +t for lower cos
+	subpd   %xmm11,%xmm5					# -(-t)
+
+	jmp 	.L__vrs4_cosf_cleanup
+
+.align 16
+.Lcossin_coscos_piby4:
+	movhlps	%xmm3,%xmm0					# x2 for 0.5x2 for upper cos
+	movapd	%xmm2,%xmm11					# x2 for 0.5x2
+	movapd	%xmm2,%xmm12					# x2 for x4
+	movapd	%xmm3,%xmm13					# x2 for x4
+	movsd	%xmm3,%xmm6					# lower x2 for x3 for sin
+	movsd	.L__real_3ff0000000000000(%rip),%xmm7
+
+	movdqa	.Lcosarray+0x30(%rip),%xmm4			# cs4
+	movdqa	.Lsincosarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lcosarray+0x10(%rip),%xmm8			# cs2
+	movapd	.Lsincosarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	subsd	%xmm0,%xmm7					# t=1.0-r  for cos
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11		# -t=r-1.0
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lcosarray+0x20(%rip),%xmm4			# c4+x2c3
+	addpd	.Lsincosarray+0x20(%rip),%xmm5			# c4+x2c3
+	addpd	.Lcosarray(%rip),%xmm8				# c2+x2c1
+	addpd	.Lsincosarray(%rip),%xmm9			# c2+x2c1
+
+	movapd	%xmm13,%xmm3					# upper=x4
+	movsd	%xmm6,%xmm3					# lower x2
+	mulsd	%xmm1,%xmm3					# lower x2*x
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm12,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# upper= x4 * zc
+								# lower=x3 * zs
+
+	movlhps	%xmm7,%xmm1
+	addpd	%xmm1,%xmm5					# +x for lower sin, +t for upper cos
+	subpd   %xmm11,%xmm4					# -(-t)
+
+	jmp 	.L__vrs4_cosf_cleanup
+
+.align 16
+.Lcossin_sinsin_piby4:						# Derived from sincos_coscos
+
+	movhlps	%xmm3,%xmm0					# x2
+	movapd	%xmm3,%xmm7
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+	movsd	.L__real_3ff0000000000000(%rip),%xmm11
+
+	movdqa	.Lsinarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lsincosarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lsinarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lsincosarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	mulpd	%xmm2,%xmm12					# x4
+	subsd	%xmm0,%xmm11					# t=1.0-r for cos
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lsinarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lsincosarray+0x20(%rip),%xmm5			# c3+x2c4
+	addpd	.Lsinarray(%rip),%xmm8				# c1+x2c2
+	addpd	.Lsincosarray(%rip),%xmm9			# c1+x2c2
+
+	mulpd	%xmm10,%xmm2					# x3
+	movapd	%xmm13,%xmm3					# upper x4 for cos
+	movsd	%xmm7,%xmm3					# lower x2 for sin
+	mulsd	%xmm1,%xmm3					# lower x3=x2*x for sin
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	movlhps	%xmm11,%xmm1					# t for upper cos and x for lower sin
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zs
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm3,%xmm5					# upper=x4 * zc
+								# lower=x3 * zs
+
+	addpd   %xmm10,%xmm4					# +x
+	addpd	%xmm1,%xmm5					# +t upper, +x lower
+
+	jmp 	.L__vrs4_cosf_cleanup
+
+.align 16
+.Lsincos_coscos_piby4:
+	movsd	%xmm3,%xmm0					# x2 for 0.5x2 for lower cos
+	movapd	%xmm2,%xmm11					# x2 for 0.5x2
+	movapd	%xmm2,%xmm12					# x2 for x4
+	movapd	%xmm3,%xmm13					# x2 for x4
+	movsd	.L__real_3ff0000000000000(%rip),%xmm7
+
+	movdqa	.Lcosarray+0x30(%rip),%xmm4			# cs4
+	movdqa	.Lcossinarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lcosarray+0x10(%rip),%xmm8			# cs2
+	movapd	.Lcossinarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0	# 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11	# 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	subsd	%xmm0,%xmm7					# t=1.0-r  for cos
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lcosarray+0x20(%rip),%xmm4			# c4+x2c3
+	addpd	.Lcossinarray+0x20(%rip),%xmm5			# c4+x2c3
+	addpd	.Lcosarray(%rip),%xmm8			# c2+x2c1
+	addpd	.Lcossinarray(%rip),%xmm9			# c2+x2c1
+
+	mulpd	%xmm1,%xmm3					# upper=x3 for sin
+	mulsd	%xmm1,%xmm3					# lower=x4 for cos
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm12,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# lower= x4 * zc
+								# upper= x3 * zs
+
+	movsd	%xmm7,%xmm1
+	subpd   %xmm11,%xmm4					# -(-t)
+	addpd	%xmm1,%xmm5					# +x for upper sin, +t for lower cos
+
+
+	jmp 	.L__vrs4_cosf_cleanup
+
+.align 16
+.Lsincos_sinsin_piby4:						# Derived from sincos_coscos
+
+	movsd	%xmm3,%xmm0					# x2
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+	movsd	.L__real_3ff0000000000000(%rip),%xmm11
+
+	movdqa	.Lsinarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lcossinarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lsinarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lcossinarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	mulpd	%xmm2,%xmm12					# x4
+	subsd	%xmm0,%xmm11					# t=1.0-r for cos
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lsinarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lcossinarray+0x20(%rip),%xmm5			# c3+x2c4
+	addpd	.Lsinarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lcossinarray(%rip),%xmm9			# c1+x2c2
+
+	mulpd	%xmm10,%xmm2					# x3
+	mulpd	%xmm1,%xmm3					# upper x3 for sin
+	mulsd	%xmm1,%xmm3					# lower x4 for cos
+
+	movhlps	%xmm1,%xmm6
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	movlhps	%xmm6,%xmm11					# upper =t ; lower =x
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zszc
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm3,%xmm5					# lower=x4 * zc
+								# upper=x3 * zs
+
+	addpd   %xmm10,%xmm4					# +x
+	addpd	%xmm11,%xmm5					# +t lower, +x upper
+
+	jmp 	.L__vrs4_cosf_cleanup
+
+.align 16
+.Lsinsin_cossin_piby4:						# Derived from sincos_coscos
+
+	movhlps	%xmm2,%xmm0					# x2
+	movapd	%xmm2,%xmm7
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+	movsd	.L__real_3ff0000000000000(%rip),%xmm11
+
+	movdqa	.Lsincosarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lsinarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lsincosarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lsinarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	mulpd	%xmm2,%xmm12					# x4
+	subsd	%xmm0,%xmm11					# t=1.0-r for cos
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lsincosarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lsinarray+0x20(%rip),%xmm5			# c3+x2c4
+	addpd	.Lsincosarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lsinarray(%rip),%xmm9				# c1+x2c2
+
+	mulpd	%xmm1,%xmm3					# x3
+	movapd	%xmm12,%xmm2					# upper x4 for cos
+	movsd	%xmm7,%xmm2					# lower x2 for sin
+	mulsd	%xmm10,%xmm2					# lower x3=x2*x for sin
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	movlhps	%xmm11,%xmm10					# t for upper cos and x for lower sin
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zszc
+
+	mulpd	%xmm3,%xmm5					# x3 * zs
+	mulpd	%xmm2,%xmm4					# upper=x4 * zc
+								# lower=x3 * zs
+
+	addpd	%xmm1,%xmm5					# +x
+	addpd   %xmm10,%xmm4					# +t upper, +x lower
+
+	jmp 	.L__vrs4_cosf_cleanup
+
+.align 16
+.Lsinsin_sincos_piby4:						# Derived from sincos_coscos
+
+	movsd	%xmm2,%xmm0					# x2
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+	movsd	.L__real_3ff0000000000000(%rip),%xmm11
+
+	movdqa	.Lcossinarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lsinarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lcossinarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lsinarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	mulpd	%xmm2,%xmm12					# x4
+	subsd	%xmm0,%xmm11					# t=1.0-r for cos
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lcossinarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lsinarray+0x20(%rip),%xmm5			# c3+x2c4
+	addpd	.Lcossinarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lsinarray(%rip),%xmm9			# c1+x2c2
+
+	mulpd	%xmm1,%xmm3					# x3
+	mulpd	%xmm10,%xmm2					# upper x3 for sin
+	mulsd	%xmm10,%xmm2					# lower x4 for cos
+
+	movhlps	%xmm10,%xmm6
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	movlhps	%xmm6,%xmm11
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zszc
+
+	mulpd	%xmm3,%xmm5					# x3 * zs
+	mulpd	%xmm2,%xmm4					# lower=x4 * zc
+								# upper=x3 * zs
+
+	addpd	%xmm1,%xmm5					# +x
+	addpd   %xmm11,%xmm4					# +t lower, +x upper
+
+	jmp 	.L__vrs4_cosf_cleanup
+
+.align 16
+.Lsinsin_sinsin_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+  #x2 = x * x;
+  #(x + x * x2 * (c1 + x2 * (c2 + x2 * (c3 + x2 * c4))));
+
+  #x + x3 * ((c1 + x2 *c2) + x4 * (c3 + x2 * c4));
+
+
+	movapd	%xmm2,%xmm0					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lsinarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lsinarray+0x30(%rip),%xmm5			# c4
+
+	mulpd	%xmm2,%xmm0					# x4
+	mulpd	%xmm3,%xmm11					# x4
+
+	movapd	.Lsinarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lsinarray+0x10(%rip),%xmm9			# c2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	addpd	.Lsinarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lsinarray+0x20(%rip),%xmm5			# c3+x2c4
+
+	mulpd	%xmm10,%xmm2					# x3
+	mulpd	%xmm1,%xmm3					# x3
+
+	addpd	.Lsinarray(%rip),%xmm8				# c1+x2c2
+	addpd	.Lsinarray(%rip),%xmm9				# c1+x2c2
+
+	mulpd	%xmm0,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm11,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zs
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm3,%xmm5					# x3 * zs
+
+	addpd	%xmm10,%xmm4					# +x
+	addpd	%xmm1,%xmm5					# +x
+
+	jmp 	.L__vrs4_cosf_cleanup
diff --git a/src/gas/vrs4expf.S b/src/gas/vrs4expf.S
new file mode 100644
index 0000000..b0e23aa
--- /dev/null
+++ b/src/gas/vrs4expf.S
@@ -0,0 +1,410 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# __vrs4_expf.s
+#
+# A vector implementation of the expf libm function.
+#  This routine implemented in single precision.  It is slightly
+#  less accurate than the double precision version, but it will
+#  be better for vectorizing.
+#
+# Prototype:
+#
+#     __m128 __vrs4_expf(__m128 x);
+#
+#   Computes e raised to the x power for 4 floats at a time.
+# Does not perform error handling, but does return C99 values for error
+# inputs.   Denormal results are truncated to 0.
+#
+#
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+        .text
+        .align 16
+        .p2align 4,,15
+
+# define local variable storage offsets
+.equ	p_temp,0	# temporary for get/put bits operation
+.equ	p_ux,0x10		# local storage for ux array
+.equ	p_m,0x20		# local storage for m array
+.equ	p_j,0x30		# local storage for m array
+.equ    save_rbx,0x040          #qword
+.equ	stack_size,0x48
+
+
+
+.globl __vrs4_expf
+       .type   __vrs4_expf,@function
+__vrs4_expf:
+	sub	$stack_size,%rsp
+        mov             %rbx,save_rbx(%rsp)
+
+
+	movaps	 %xmm0,p_ux(%rsp)
+        maxps   .L__real_m8192(%rip),%xmm0   # protect against small input values
+
+
+#        /* Find m, z1 and z2 such that exp(x) = 2**m * (z1 + z2) */
+#      Step 1. Reduce the argument.
+	#    r = x * thirtytwo_by_logbaseof2;
+	movaps	.L__real_thirtytwo_by_log2(%rip),%xmm2	#
+	mulps	%xmm0,%xmm2
+	xor		%rax,%rax
+        minps   .L__real_8192(%rip),%xmm2   # protect against large input values
+
+#    /* Set n = nearest integer to r */
+	cvtps2dq	%xmm2,%xmm3
+	lea		.L__two_to_jby32_table(%rip),%rdi
+	cvtdq2ps	%xmm3,%xmm1
+
+
+#    r1 = x - n * logbaseof2_by_32_lead;
+	movaps	.L__real_log2_by_32_head(%rip),%xmm2
+	mulps	%xmm1,%xmm2
+	subps	%xmm2,%xmm0				# r1 in xmm0,
+
+#    r2 = - n * logbaseof2_by_32_lead;
+	mulps	.L__real_log2_by_32_tail(%rip),%xmm1
+
+#    j = n & 0x0000001f;
+	movdqa	%xmm3,%xmm4
+	movdqa	.L__int_mask_1f(%rip),%xmm2
+	pand	%xmm4,%xmm2
+	movdqa	%xmm2,p_j(%rsp)
+#    f1 = two_to_jby32_lead_table[j];
+
+#    *m = (n - j) / 32;
+	psubd	%xmm2,%xmm4
+	psrad	$5,%xmm4
+	movdqa	%xmm4,p_m(%rsp)
+
+	movaps	%xmm0,%xmm3
+	addps	%xmm1,%xmm3
+
+	mov		p_j(%rsp),%eax 			# get an individual index
+	mov		(%rdi,%rax,4),%edx		# get the f1 value
+	mov		%edx,p_j(%rsp) 			# save the f1 value
+
+#      Step 2. Compute the polynomial.
+#     q = r1 +
+#              r*r*( 5.00000000000000008883e-01 +
+#                      r*( 1.66666666665260878863e-01 +
+#                      r*( 4.16666666662260795726e-02 +
+#                      r*( 8.33336798434219616221e-03 +
+#                      r*( 1.38889490863777199667e-03 )))));
+#    q = r + r^2/2 + r^3/6 + r^4/24 + r^5/120 + r^6/720
+#    q = r + r^2/2 + r^3/6 + r^4/24 good enough for single precision
+	movaps	%xmm3,%xmm4
+	movaps	%xmm3,%xmm2			# x*x
+	mulps	%xmm2,%xmm2
+	mulps	.L__real_1_24(%rip),%xmm4	# /24
+
+	mov		p_j+4(%rsp),%eax 			# get an individual index
+	mov		(%rdi,%rax,4),%edx		# get the f1 value
+	mov		%edx,p_j+4(%rsp) 			# save the f1 value
+
+	addps 	.L__real_1_6(%rip),%xmm4	# +1/6
+
+	mulps	%xmm2,%xmm3			# x^3
+	mov		p_j+8(%rsp),%eax 			# get an individual index
+	mov		(%rdi,%rax,4),%edx		# get the f1 value
+	mov		%edx,p_j+8(%rsp) 			# save the f1 value
+	mulps	.L__real_half(%rip),%xmm2	# x^2/2
+	mulps	%xmm3,%xmm4			# *x^3
+
+	mov		p_j+12(%rsp),%eax 			# get an individual index
+	mov		(%rdi,%rax,4),%edx		# get the f1 value
+	mov		%edx,p_j+12(%rsp) 			# save the f1 value
+	addps	%xmm4,%xmm1			# +r2
+
+	addps	%xmm2,%xmm1			# + x^2/2
+	addps	%xmm1,%xmm0			# +r1
+
+# deal with infinite or denormal results
+        movdqa  p_m(%rsp),%xmm1
+        movdqa  p_m(%rsp),%xmm2
+        pcmpgtd .L__int_127(%rip),%xmm2
+        pminsw  .L__int_128(%rip),%xmm1 # ceil at 128
+        movmskps        %xmm2,%eax
+        test            $0x0f,%eax
+
+        paddd   .L__int_127(%rip),%xmm1 # add bias
+
+#    *z2 = f2 + ((f1 + f2) * q);
+        mulps   p_j(%rsp),%xmm0         # * f1
+        addps   p_j(%rsp),%xmm0         # + f1
+        jnz             .L__exp_largef
+.L__check1:
+
+	pxor	%xmm2,%xmm2			# floor at 0
+	pmaxsw	%xmm2,%xmm1
+
+	pslld	$23,%xmm1			# build 2^n
+
+	movaps	%xmm1,%xmm2
+
+
+# check for infinity or nan
+	movaps	p_ux(%rsp),%xmm1
+	andps	.L__real_infinity(%rip),%xmm1
+	cmpps	$0,.L__real_infinity(%rip),%xmm1
+	movmskps	%xmm1,%eax
+	test		$0xf,%eax
+
+
+# end of splitexp
+#        /* Scale (z1 + z2) by 2.0**m */
+#      Step 3. Reconstitute.
+
+	mulps	%xmm2,%xmm0		# result *= 2^n
+
+# we'd like to avoid a branch, and can use cmp's and and's to
+# eliminate them.  But it adds cycles for normal cases
+# to handle events that are supposed to be exceptions.
+#  Using this branch with the
+# check above results in faster code for the normal cases.
+# And branch mispredict penalties should only come into
+# play for nans and infinities.
+	jnz		.L__exp_naninf
+
+#
+.L__final_check:
+        mov             save_rbx(%rsp),%rbx             # restore rbx
+	add		$stack_size,%rsp
+	ret
+
+#  deal with nans and infinities
+
+.L__exp_naninf:
+	movaps	%xmm0,p_temp(%rsp)		# save the computed values
+	mov		%eax,%ecx				# save the error mask
+	test	$1,%ecx					# first value?
+	jz		.__Lni2
+	mov		p_ux(%rsp),%edx			# get the input
+	call	.L__naninf
+	mov		%edx,p_temp(%rsp)		# save the new result
+.__Lni2:
+	test	$2,%ecx					# first value?
+	jz		.__Lni3
+	mov		p_ux+4(%rsp),%edx		# get the input
+	call	.L__naninf
+	mov		%edx,p_temp+4(%rsp)		# save the new result
+.__Lni3:
+	test	$4,%ecx					# first value?
+	jz		.__Lni4
+	mov		p_ux+8(%rsp),%edx		# get the input
+	call	.L__naninf
+	mov		%edx,p_temp+8(%rsp)		# save the new result
+.__Lni4:
+	test	$8,%ecx					# first value?
+	jz		.__Lnie
+	mov		p_ux+12(%rsp),%edx		# get the input
+	call	.L__naninf
+	mov		%edx,p_temp+12(%rsp)		# save the new result
+.__Lnie:
+	movaps	p_temp(%rsp),%xmm0		# get the answers
+	jmp		.L__final_check
+
+
+# a simple subroutine to check a scalar input value for infinity
+# or NaN and return the correct result
+# expects input in edx, and returns value in edx.  Destroys eax.
+.L__naninf:
+	mov	$0x0007FFFFF,%eax
+	test	%eax,%edx
+	jnz		.L__enan		# jump if mantissa not zero, so it's a NaN
+# inf
+	mov		%edx,%eax
+	rcl		$1,%eax
+	jnc		.L__r				# exp(+inf) = inf
+	xor		%edx,%edx				# exp(-inf) = 0
+	jmp		.L__r
+
+#NaN
+.L__enan:
+	mov		$0x000400000,%eax	# convert to quiet
+	or		%eax,%edx
+.L__r:
+	ret
+
+        .align 16
+#  deal with m > 127.  In some instances, rounding during calculations
+#  can result in infinity when it shouldn't.  For these cases, we scale
+#  m down, and scale the mantissa up.
+
+.L__exp_largef:
+        movdqa    %xmm0,p_temp(%rsp)    # save the mantissa portion
+        movdqa    %xmm1,p_m(%rsp)       # save the exponent portion
+        mov       %eax,%ecx              # save the error mask
+        test    $1,%ecx                  # first value?
+        jz       .L__Lf2
+        mov      p_m(%rsp),%edx # get the exponent
+        sub      $1,%edx                # scale it down
+        mov      %edx,p_m(%rsp)       # save the exponent
+        movss   p_temp(%rsp),%xmm3     # get the mantissa
+        mulss   .L__real_two(%rip),%xmm3        # scale it up
+        movss    %xmm3,p_temp(%rsp)   # save the mantissa
+.L__Lf2:
+        test    $2,%ecx                 # second value?
+        jz       .L__Lf3
+        mov      p_m+4(%rsp),%edx # get the exponent
+        sub      $1,%edx                # scale it down
+        mov      %edx,p_m+4(%rsp)       # save the exponent
+        movss   p_temp+4(%rsp),%xmm3     # get the mantissa
+        mulss   .L__real_two(%rip),%xmm3        # scale it up
+        movss     %xmm3,p_temp+4(%rsp)   # save the mantissa
+.L__Lf3:
+        test    $4,%ecx                 # third value?
+        jz       .L__Lf4
+        mov      p_m+8(%rsp),%edx # get the exponent
+        sub      $1,%edx                # scale it down
+        mov      %edx,p_m+8(%rsp)       # save the exponent
+        movss   p_temp+8(%rsp),%xmm3     # get the mantissa
+        mulss   .L__real_two(%rip),%xmm3        # scale it up
+        movss    %xmm3,p_temp+8(%rsp)   # save the mantissa
+.L__Lf4:
+        test    $8,%ecx                                 # fourth value?
+        jz       .L__Lfe
+        mov      p_m+12(%rsp),%edx        # get the exponent
+        sub      $1,%edx                 # scale it down
+        mov      %edx,p_m+12(%rsp)      # save the exponent
+        movss   p_temp+12(%rsp),%xmm3    # get the mantissa
+        mulss   .L__real_two(%rip),%xmm3        # scale it up
+        movss     %xmm3,p_temp+12(%rsp)  # save the mantissa
+.L__Lfe:
+        movaps  p_temp(%rsp),%xmm0      # restore the mantissa portion back
+        movdqa  p_m(%rsp),%xmm1         # restore the exponent portion
+        jmp             .L__check1
+
+	.data
+        .align 64
+
+.L__real_half:			.long 0x3f000000	# 1/2
+				.long 0x3f000000
+				.long 0x3f000000
+				.long 0x3f000000
+
+.L__real_two:			.long 0x40000000	# 2
+				.long 0x40000000
+				.long 0x40000000
+				.long 0x40000000
+
+.L__real_8192:			.long 0x46000000	# 8192, to protect against really large numbers
+				.long 0x46000000
+				.long 0x46000000
+				.long 0x46000000
+.L__real_m8192:			.long 0xC6000000	# -8192, to protect against really small numbers
+				.long 0xC6000000
+				.long 0xC6000000
+				.long 0xC6000000
+
+.L__real_thirtytwo_by_log2: 	.long 0x4238AA3B	# thirtytwo_by_log2
+				.long 0x4238AA3B
+				.long 0x4238AA3B
+				.long 0x4238AA3B
+
+.L__real_log2_by_32:		.long 0x3CB17218	# log2_by_32
+				.long 0x3CB17218
+				.long 0x3CB17218
+				.long 0x3CB17218
+
+.L__real_log2_by_32_head:	.long 0x3CB17000	# log2_by_32
+				.long 0x3CB17000
+				.long 0x3CB17000
+				.long 0x3CB17000
+
+.L__real_log2_by_32_tail:	.long 0xB585FDF4	# log2_by_32
+				.long 0xB585FDF4
+				.long 0xB585FDF4
+				.long 0xB585FDF4
+
+.L__real_1_6:			.long 0x3E2AAAAB	# 0.16666666666 used in polynomial
+				.long 0x3E2AAAAB
+				.long 0x3E2AAAAB
+				.long 0x3E2AAAAB
+
+.L__real_1_24:			.long 0x3D2AAAAB	# 0.041666668 used in polynomial
+				.long 0x3D2AAAAB
+				.long 0x3D2AAAAB
+				.long 0x3D2AAAAB
+
+.L__real_infinity:		.long 0x7f800000	# infinity
+				.long 0x7f800000
+				.long 0x7f800000
+				.long 0x7f800000
+.L__int_mask_1f:		.long 0x00000001f
+				.long 0x00000001f
+				.long 0x00000001f
+				.long 0x00000001f
+.L__int_128:			.long 0x000000080
+				.long 0x000000080
+				.long 0x000000080
+				.long 0x000000080
+.L__int_127:			.long 0x00000007f
+				.long 0x00000007f
+				.long 0x00000007f
+				.long 0x00000007f
+
+
+.L__two_to_jby32_table:
+   .long  0x3F800000  #          1
+   .long  0x3F82CD87  #  1.0218972
+   .long  0x3F85AAC3  #  1.0442737
+   .long  0x3F88980F  #  1.0671405
+   .long  0x3F8B95C2  #  1.0905077
+   .long  0x3F8EA43A  #  1.1143868
+   .long  0x3F91C3D3  #  1.1387886
+   .long  0x3F94F4F0  #  1.1637249
+   .long  0x3F9837F0  #  1.1892071
+   .long  0x3F9B8D3A  #  1.2152474
+   .long  0x3F9EF532  #  1.2418578
+   .long  0x3FA27043  #   1.269051
+   .long  0x3FA5FED7  #  1.2968396
+   .long  0x3FA9A15B  #  1.3252367
+   .long  0x3FAD583F  #  1.3542556
+   .long  0x3FB123F6  #  1.3839099
+   .long  0x3FB504F3  #  1.4142135
+   .long  0x3FB8FBAF  #  1.4451808
+   .long  0x3FBD08A4  #  1.4768262
+   .long  0x3FC12C4D  #  1.5091645
+   .long  0x3FC5672A  #  1.5422108
+   .long  0x3FC9B9BE  #  1.5759809
+   .long  0x3FCE248C  #  1.6104903
+   .long  0x3FD2A81E  #  1.6457555
+   .long  0x3FD744FD  #  1.6817929
+   .long  0x3FDBFBB8  #  1.7186193
+   .long  0x3FE0CCDF  #  1.7562522
+   .long  0x3FE5B907  #  1.7947091
+   .long  0x3FEAC0C7  #  1.8340081
+   .long  0x3FEFE4BA  #  1.8741677
+   .long  0x3FF5257D  #  1.9152066
+   .long  0x3FFA83B3  #  1.9571441
+   .long 0					# for alignment
+
diff --git a/src/gas/vrs4log10f.S b/src/gas/vrs4log10f.S
new file mode 100644
index 0000000..d6d9ac8
--- /dev/null
+++ b/src/gas/vrs4log10f.S
@@ -0,0 +1,646 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrs4logf.s
+#
+# A vector implementation of the logf libm function.
+#  This routine implemented in single precision.  It is slightly
+#  less accurate than the double precision version, but it will
+#  be better for vectorizing.
+#
+# Prototype:
+#
+#     __m128 __vrs4_log10f(__m128 x);
+#
+#   Computes the natural log of x.
+#   Returns proper C99 values, but may not raise status flags properly.
+#   Less than 1 ulp of error.
+#
+#
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+        .text
+        .align 16
+        .p2align 4,,15
+
+# define local variable storage offsets
+.equ	p_x,0			# save x
+.equ	p_idx,0x010		# xmmword index
+.equ	p_z1,0x020		# xmmword index
+.equ	p_q,0x030		# xmmword index
+.equ	p_corr,0x040		# xmmword index
+.equ	p_omask,0x050		# xmmword index
+.equ	save_xmm6,0x060		#
+.equ	save_rbx,0x070		#
+
+.equ	stack_size,0x088
+
+
+
+.globl __vrs4_log10f
+    .type   __vrs4_log10f,@function
+__vrs4_log10f:
+	sub		$stack_size,%rsp
+	mov		%rbx,save_rbx(%rsp)	# save rbx
+
+# check e as a special case
+	movdqa	%xmm0,p_x(%rsp)	# save x
+#	movdqa	%xmm0,%xmm2
+#	cmpps	$0,.L__real_ef(%rip),%xmm2
+#	movmskps	%xmm2,%r9d
+
+#
+# compute the index into the log tables
+#
+	movdqa	%xmm0,%xmm3
+	movaps	%xmm0,%xmm1
+	psrld	$23,%xmm3
+	subps	.L__real_one(%rip),%xmm1
+	psubd	.L__mask_127(%rip),%xmm3
+	cvtdq2ps	%xmm3,%xmm6			# xexp
+
+
+	movdqa	%xmm0,%xmm3
+	pand	.L__real_mant(%rip),%xmm3
+	xor		%r8,%r8
+	movdqa	%xmm3,%xmm2
+	movaps	.L__real_half(%rip),%xmm5							# .5
+
+#/* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+	psrld	$16,%xmm3
+	lea		.L__np_ln_lead_table(%rip),%rdx
+	movdqa	%xmm3,%xmm4
+	psrld	$1,%xmm3
+	paddd	.L__mask_040(%rip),%xmm3
+	pand	.L__mask_001(%rip),%xmm4
+	paddd	%xmm4,%xmm3
+	cvtdq2ps	%xmm3,%xmm1
+	packssdw	%xmm3,%xmm3
+	movq	%xmm3,p_idx(%rsp)
+
+
+# reduce and get u
+	movdqa	%xmm0,%xmm3
+	orps		.L__real_half(%rip),%xmm2
+
+
+	mulps	.L__real_3c000000(%rip),%xmm1				# f1 = index/128
+
+
+	subps	%xmm1,%xmm2											# f2 = f - f1
+	mulps	%xmm2,%xmm5
+	addps	%xmm5,%xmm1
+
+	divps	%xmm1,%xmm2				# u
+
+	mov		p_idx(%rsp),%rcx 			# get the indexes
+	mov		%cx,%r8w
+	ror		$16,%rcx
+	mov		-256(%rdx,%r8,4),%eax		# get the f1 value
+
+	mov		%cx,%r8w
+	ror		$16,%rcx
+	mov		-256(%rdx,%r8,4),%ebx		# get the f1 value
+	shl		$32,%rbx
+	or		%rbx,%rax
+	mov		 %rax,p_z1(%rsp) 			# save the f1 values
+
+	mov		%cx,%r8w
+	ror		$16,%rcx
+	mov		-256(%rdx,%r8,4),%eax		# get the f1 value
+
+	mov		%cx,%r8w
+	ror		$16,%rcx
+	or		-256(%rdx,%r8,4),%ebx		# get the f1 value
+	shl		$32,%rbx
+	or		%rbx,%rax
+	mov		 %rax,p_z1+8(%rsp) 			# save the f1 value
+
+# solve for ln(1+u)
+	movaps	%xmm2,%xmm1				# u
+	mulps	%xmm2,%xmm2				# u^2
+	movaps	%xmm2,%xmm5
+	lea		.L__np_ln_tail_table(%rip),%rdx
+	movaps	.L__real_cb3(%rip),%xmm3
+	mulps	%xmm2,%xmm3				#Cu2
+	mulps	%xmm1,%xmm5				# u^3
+	addps	.L__real_cb2(%rip),%xmm3 #B+Cu2
+	movaps	%xmm2,%xmm4
+	mulps	%xmm5,%xmm4				# u^5
+	movaps	.L__real_log2_lead(%rip),%xmm2
+
+	mulps	.L__real_cb1(%rip),%xmm5 #Au3
+	addps	%xmm5,%xmm1				# u+Au3
+	mulps	%xmm3,%xmm4				# u5(B+Cu2)
+
+	addps	%xmm4,%xmm1				# poly
+
+# recombine
+	mov		%cx,%r8w
+	shr		$16,%rcx
+	mov		-256(%rdx,%r8,4),%eax		# get the f1 value
+
+	mov		%cx,%r8w
+	shr		$16,%rcx
+	or		-256(%rdx,%r8,4),%ebx		# get the f1 value
+	shl		$32,%rbx
+	or		%rbx,%rax
+	mov		 %rax,p_q(%rsp) 			# save the f1 value
+
+	mov		%cx,%r8w
+	shr		$16,%rcx
+	mov		-256(%rdx,%r8,4),%eax		# get the f1 value
+
+	mov		%cx,%r8w
+	mov		-256(%rdx,%r8,4),%ebx		# get the f1 value
+	shl		$32,%rbx
+	or		%rbx,%rax
+	mov		 %rax,p_q+8(%rsp) 			# save the f1 value
+
+	addps	p_q(%rsp),%xmm1 #z2	+=q
+
+	movaps	p_z1(%rsp),%xmm0			# z1  values
+
+	mulps	%xmm6,%xmm2
+	addps	%xmm2,%xmm0				#r1
+	movaps	%xmm0,%xmm2
+	mulps	.L__real_log2_tail(%rip),%xmm6
+	addps	%xmm6,%xmm1				#r2
+	movaps	%xmm1,%xmm3
+
+#	logef to log10f
+	mulps 	.L__real_log10e_tail(%rip),%xmm1
+	mulps 	.L__real_log10e_tail(%rip),%xmm0
+	mulps 	.L__real_log10e_lead(%rip),%xmm3
+	mulps 	.L__real_log10e_lead(%rip),%xmm2
+	addps 	%xmm1,%xmm0
+	addps 	%xmm3,%xmm0
+	addps	%xmm2,%xmm0
+#	addps	%xmm1,%xmm0
+
+# check for e
+#	test		$0x0f,%r9d
+#	jnz			.L__vlogf_e
+.L__f1:
+
+# check for negative numbers or zero
+	xorps	%xmm1,%xmm1
+	cmpps	$1,p_x(%rsp),%xmm1	# 0 greater than =?. catches NaNs also.
+	movmskps	%xmm1,%r9d
+	cmp		$0x0f,%r9d
+	jnz		.L__z_or_neg
+
+.L__f2:
+##  if +inf
+	movaps	p_x(%rsp),%xmm3
+	cmpps	$0,.L__real_inf(%rip),%xmm3
+	movmskps	%xmm3,%r9d
+	test		$0x0f,%r9d
+	jnz		.L__log_inf
+.L__f3:
+
+	movaps	p_x(%rsp),%xmm3
+	subps	.L__real_one(%rip),%xmm3
+	andps	.L__real_notsign(%rip),%xmm3
+	cmpps	$2,.L__real_threshold(%rip),%xmm3
+	movmskps	%xmm3,%r9d
+	test	$0x0f,%r9d
+	jnz		.L__near_one
+
+
+.L__finish:
+	mov		save_rbx(%rsp),%rbx		# restore rbx
+	add		$stack_size,%rsp
+	ret
+
+.L__vlogf_e:
+	movdqa	p_x(%rsp),%xmm2
+	cmpps	$0,.L__real_ef(%rip),%xmm2
+	movdqa	%xmm2,%xmm3
+	andnps	%xmm0,%xmm3							# keep the non-e values
+	andps	.L__real_one(%rip),%xmm2			# setup the 1 values
+	orps	%xmm3,%xmm2							# merge
+	movdqa	%xmm2,%xmm0							# and replace
+	jmp		.L__f1
+
+	.align	16
+.L__near_one:
+# saves 10 cycles
+#      r = x - 1.0;
+	movdqa	%xmm3,p_omask(%rsp)	# save ones mask
+	movaps	p_x(%rsp),%xmm3
+	movaps	.L__real_two(%rip),%xmm2
+	subps	.L__real_one(%rip),%xmm3	   # r
+#      u          = r / (2.0 + r);
+	addps	%xmm3,%xmm2
+	movaps	%xmm3,%xmm1
+	divps	%xmm2,%xmm1		# u
+	movaps	.L__real_ca4(%rip),%xmm4	  #D
+	movaps	.L__real_ca3(%rip),%xmm5	  #C
+#      correction = r * u;
+	movaps	%xmm3,%xmm6
+	mulps	%xmm1,%xmm6		# correction
+	movdqa	%xmm6,p_corr(%rsp)	# save correction
+#      u          = u + u;
+	addps	%xmm1,%xmm1		#u
+	movaps	%xmm1,%xmm2
+	mulps	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulps	%xmm1,%xmm5		# Cu
+	movaps	%xmm1,%xmm6
+	mulps	%xmm2,%xmm6		# u^3
+	mulps	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulps	%xmm6,%xmm4		#Du^3
+
+	addps	.L__real_ca1(%rip),%xmm2	# +A
+	movaps	%xmm6,%xmm1
+	mulps	%xmm1,%xmm1		# u^6
+	addps	%xmm4,%xmm5		#Cu+Du3
+
+	mulps	%xmm6,%xmm2		#u3(A+Bu2)
+	mulps	%xmm5,%xmm1		#u6(Cu+Du3)
+	addps	%xmm1,%xmm2
+	subps	p_corr(%rsp),%xmm2		# -correction
+
+	movaps  %xmm3,%xmm5 	#r1=r
+	pand 	.L__mask_lower(%rip),%xmm5
+	subps	%xmm5,%xmm3
+	addps	%xmm3,%xmm2	#r2 = r2 + (r-r1)
+
+	movaps	%xmm5,%xmm3
+	movaps	%xmm2,%xmm1
+
+	mulps 	.L__real_log10e_tail(%rip),%xmm2
+	mulps 	.L__real_log10e_tail(%rip),%xmm3
+	mulps 	.L__real_log10e_lead(%rip),%xmm1
+	mulps 	.L__real_log10e_lead(%rip),%xmm5
+	addps 	%xmm2,%xmm3
+	addps 	%xmm1,%xmm3
+	addps	%xmm5,%xmm3
+#      return r + r2;
+#	addps	%xmm2,%xmm3
+
+	movdqa	p_omask(%rsp),%xmm6
+	movdqa	%xmm6,%xmm2
+	andnps	%xmm0,%xmm6					# keep the non-nearone values
+	andps	%xmm3,%xmm2					# setup the nearone values
+	orps	%xmm6,%xmm2					# merge
+	movdqa	%xmm2,%xmm0					# and replace
+
+	jmp		.L__finish
+
+# we have a zero, a negative number, or both.
+# the mask is already in .LNaNs,%xmm1 are also picked up here, along with -inf.
+.L__z_or_neg:
+# deal with negatives first
+	movdqa	%xmm1,%xmm3
+	andps	%xmm0,%xmm3							# keep the non-error values
+	andnps	.L__real_nan(%rip),%xmm1			# setup the nan values
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+# check for +/- 0
+	xorps	%xmm1,%xmm1
+	cmpps	$0,p_x(%rsp),%xmm1	# 0 ?.
+	movmskps	%xmm1,%r9d
+	test		$0x0f,%r9d
+	jz		.L__zn2
+
+	movdqa	%xmm1,%xmm3
+	andnps	%xmm0,%xmm3							# keep the non-error values
+	andps	.L__real_ninf(%rip),%xmm1		# ; C99 specs -inf for +-0
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+
+.L__zn2:
+# check for NaNs
+	movaps	p_x(%rsp),%xmm3
+	andps	.L__real_inf(%rip),%xmm3
+	cmpps	$0,.L__real_inf(%rip),%xmm3		# mask for max exponent
+
+	movdqa	p_x(%rsp),%xmm4
+	pand	.L__real_mant(%rip),%xmm4		# mask for non-zero mantissa
+	pcmpeqd	.L__real_zero(%rip),%xmm4
+	pandn	%xmm3,%xmm4							# mask for NaNs
+	movdqa	%xmm4,%xmm2
+	movdqa	p_x(%rsp),%xmm1			# isolate the NaNs
+	pand	%xmm4,%xmm1
+
+	pand	.L__real_qnanbit(%rip),%xmm4		# now we have a mask that will set QNaN bit
+	por		%xmm1,%xmm4							# turn SNaNs to QNaNs
+
+	movdqa	%xmm2,%xmm1
+	andnps	%xmm0,%xmm2							# keep the non-error values
+	orps	%xmm4,%xmm2							# merge
+	movdqa	%xmm2,%xmm0							# and replace
+	xorps	%xmm4,%xmm4
+
+	jmp		.L__f2
+
+# handle only +inf	 log(+inf) = inf
+.L__log_inf:
+	movdqa	%xmm3,%xmm1
+	andnps	%xmm0,%xmm3							# keep the non-error values
+	andps	p_x(%rsp),%xmm1			# setup the +inf values
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+	jmp		.L__f3
+
+
+        .data
+        .align 64
+
+.L__real_zero:				.quad 0x00000000000000000	# 1.0
+					.quad 0x00000000000000000
+.L__real_one:				.quad 0x03f8000003f800000	# 1.0
+					.quad 0x03f8000003f800000
+.L__real_two:				.quad 0x04000000040000000	# 1.0
+					.quad 0x04000000040000000
+.L__real_ninf:				.quad 0x0ff800000ff800000	# -inf
+					.quad 0x0ff800000ff800000
+.L__real_inf:				.quad 0x07f8000007f800000	# +inf
+					.quad 0x07f8000007f800000
+.L__real_nan:				.quad 0x07fc000007fc00000	# NaN
+					.quad 0x07fc000007fc00000
+.L__real_ef:				.quad 0x0402DF854402DF854	# float e
+					.quad 0x0402DF854402DF854
+
+.L__real_sign:				.quad 0x08000000080000000	# sign bit
+					.quad 0x08000000080000000
+.L__real_notsign:			.quad 0x07ffFFFFF7ffFFFFF	# ^sign bit
+					.quad 0x07ffFFFFF7ffFFFFF
+.L__real_qnanbit:			.quad 0x00040000000400000	# quiet nan bit
+					.quad 0x00040000000400000
+.L__real_mant:				.quad 0x0007FFFFF007FFFFF	# mantipsa bits
+					.quad 0x0007FFFFF007FFFFF
+.L__real_3c000000:			.quad 0x03c0000003c000000	# /* 0.0078125 = 1/128 */
+					.quad 0x03c0000003c000000
+.L__mask_127:				.quad 0x00000007f0000007f	#
+					.quad 0x00000007f0000007f
+.L__mask_040:				.quad 0x00000004000000040	#
+					.quad 0x00000004000000040
+.L__mask_001:				.quad 0x00000000100000001	#
+					.quad 0x00000000100000001
+
+
+.L__real_threshold:			.quad 0x03CF5C28F3CF5C28F	# .03
+					.quad 0x03CF5C28F3CF5C28F
+
+.L__real_ca1:				.quad 0x03DAAAAAB3DAAAAAB	# 8.33333333333317923934e-02
+					.quad 0x03DAAAAAB3DAAAAAB
+.L__real_ca2:				.quad 0x03C4CCCCD3C4CCCCD	# 1.25000000037717509602e-02
+					.quad 0x03C4CCCCD3C4CCCCD
+.L__real_ca3:				.quad 0x03B1249183B124918	# 2.23213998791944806202e-03
+					.quad 0x03B1249183B124918
+.L__real_ca4:				.quad 0x039E401A639E401A6	# 4.34887777707614552256e-04
+					.quad 0x039E401A639E401A6
+.L__real_cb1:				.quad 0x03DAAAAAB3DAAAAAB	# 8.33333333333333593622e-02
+					.quad 0x03DAAAAAB3DAAAAAB
+.L__real_cb2:				.quad 0x03C4CCCCD3C4CCCCD	# 1.24999999978138668903e-02
+					.quad 0x03C4CCCCD3C4CCCCD
+.L__real_cb3:				.quad 0x03B124A123B124A12	# 2.23219810758559851206e-03
+					.quad 0x03B124A123B124A12
+.L__real_log2_lead:        		.quad 0x03F3170003F317000  # 0.693115234375
+                        		.quad 0x03F3170003F317000
+.L__real_log2_tail:        		.quad 0x03805FDF43805FDF4  # 0.000031946183
+                        		.quad 0x03805FDF43805FDF4
+.L__real_half:				.quad 0x03f0000003f000000	# 1/2
+					.quad 0x03f0000003f000000
+.L__real_log10e_lead:	     .quad 0x03EDE00003EDE0000	# log10e_lead  0.4335937500
+                       .quad 0x03EDE00003EDE0000
+.L__real_log10e_tail:	      .quad 0x03A37B1523A37B152  # log10e_tail  0.0007007319
+                       .quad 0x03A37B1523A37B152
+
+
+.L__mask_lower:				.quad 0x0ffff0000ffff0000	#
+					.quad 0x0ffff0000ffff0000
+
+.L__np_ln__table:
+	.quad	0x0000000000000000 		# 0.00000000000000000000e+00
+	.quad	0x3F8FC0A8B0FC03E4		# 1.55041813850402832031e-02
+	.quad	0x3F9F829B0E783300		# 3.07716131210327148438e-02
+	.quad	0x3FA77458F632DCFC		# 4.58095073699951171875e-02
+	.quad	0x3FAF0A30C01162A6		# 6.06245994567871093750e-02
+	.quad	0x3FB341D7961BD1D1		# 7.52233862876892089844e-02
+	.quad	0x3FB6F0D28AE56B4C		# 8.96121263504028320312e-02
+	.quad	0x3FBA926D3A4AD563		# 1.03796780109405517578e-01
+	.quad	0x3FBE27076E2AF2E6		# 1.17783010005950927734e-01
+	.quad	0x3FC0D77E7CD08E59		# 1.31576299667358398438e-01
+	.quad	0x3FC29552F81FF523		# 1.45181953907012939453e-01
+	.quad	0x3FC44D2B6CCB7D1E		# 1.58604979515075683594e-01
+	.quad	0x3FC5FF3070A793D4		# 1.71850204467773437500e-01
+	.quad	0x3FC7AB890210D909		# 1.84922337532043457031e-01
+	.quad	0x3FC9525A9CF456B4		# 1.97825729846954345703e-01
+	.quad	0x3FCAF3C94E80BFF3		# 2.10564732551574707031e-01
+	.quad	0x3FCC8FF7C79A9A22		# 2.23143517971038818359e-01
+	.quad	0x3FCE27076E2AF2E6		# 2.35566020011901855469e-01
+	.quad	0x3FCFB9186D5E3E2B		# 2.47836112976074218750e-01
+	.quad	0x3FD0A324E27390E3		# 2.59957492351531982422e-01
+	.quad	0x3FD1675CABABA60E		# 2.71933674812316894531e-01
+	.quad	0x3FD22941FBCF7966		# 2.83768117427825927734e-01
+	.quad	0x3FD2E8E2BAE11D31		# 2.95464158058166503906e-01
+	.quad	0x3FD3A64C556945EA		# 3.07025015354156494141e-01
+	.quad	0x3FD4618BC21C5EC2		# 3.18453729152679443359e-01
+	.quad	0x3FD51AAD872DF82D		# 3.29753279685974121094e-01
+	.quad	0x3FD5D1BDBF5809CA		# 3.40926527976989746094e-01
+	.quad	0x3FD686C81E9B14AF		# 3.51976394653320312500e-01
+	.quad	0x3FD739D7F6BBD007		# 3.62905442714691162109e-01
+	.quad	0x3FD7EAF83B82AFC3		# 3.73716354370117187500e-01
+	.quad	0x3FD89A3386C1425B		# 3.84411692619323730469e-01
+	.quad	0x3FD947941C2116FB		# 3.94993782043457031250e-01
+	.quad	0x3FD9F323ECBF984C		# 4.05465066432952880859e-01
+	.quad	0x3FDA9CEC9A9A084A		# 4.15827870368957519531e-01
+	.quad	0x3FDB44F77BCC8F63		# 4.26084339618682861328e-01
+	.quad	0x3FDBEB4D9DA71B7C		# 4.36236739158630371094e-01
+	.quad	0x3FDC8FF7C79A9A22		# 4.46287095546722412109e-01
+	.quad	0x3FDD32FE7E00EBD5		# 4.56237375736236572266e-01
+	.quad	0x3FDDD46A04C1C4A1		# 4.66089725494384765625e-01
+	.quad	0x3FDE744261D68788		# 4.75845873355865478516e-01
+	.quad	0x3FDF128F5FAF06ED		# 4.85507786273956298828e-01
+	.quad	0x3FDFAF588F78F31F		# 4.95077252388000488281e-01
+	.quad	0x3FE02552A5A5D0FF		# 5.04556000232696533203e-01
+	.quad	0x3FE0723E5C1CDF40		# 5.13945698738098144531e-01
+	.quad	0x3FE0BE72E4252A83		# 5.23248136043548583984e-01
+	.quad	0x3FE109F39E2D4C97		# 5.32464742660522460938e-01
+	.quad	0x3FE154C3D2F4D5EA		# 5.41597247123718261719e-01
+	.quad	0x3FE19EE6B467C96F		# 5.50647079944610595703e-01
+	.quad	0x3FE1E85F5E7040D0		# 5.59615731239318847656e-01
+	.quad	0x3FE23130D7BEBF43		# 5.68504691123962402344e-01
+	.quad	0x3FE2795E1289B11B		# 5.77315330505371093750e-01
+	.quad	0x3FE2C0E9ED448E8C		# 5.86049020290374755859e-01
+	.quad	0x3FE307D7334F10BE		# 5.94707071781158447266e-01
+	.quad	0x3FE34E289D9CE1D3		# 6.03290796279907226562e-01
+	.quad	0x3FE393E0D3562A1A		# 6.11801505088806152344e-01
+	.quad	0x3FE3D9026A7156FB		# 6.20240390300750732422e-01
+	.quad	0x3FE41D8FE84672AE		# 6.28608644008636474609e-01
+	.quad	0x3FE4618BC21C5EC2		# 6.36907458305358886719e-01
+	.quad	0x3FE4A4F85DB03EBB		# 6.45137906074523925781e-01
+	.quad	0x3FE4E7D811B75BB1		# 6.53301239013671875000e-01
+	.quad	0x3FE52A2D265BC5AB		# 6.61398470401763916016e-01
+	.quad	0x3FE56BF9D5B3F399		# 6.69430613517761230469e-01
+	.quad	0x3FE5AD404C359F2D		# 6.77398800849914550781e-01
+	.quad	0x3FE5EE02A9241675		# 6.85303986072540283203e-01
+	.quad	0x3FE62E42FEFA39EF		# 6.93147122859954833984e-01
+	.quad 0					# for alignment
+
+.L__np_ln_lead_table:
+    .long 0x00000000  # 0.000000000000 0
+    .long 0x3C7E0000  # 0.015502929688 1
+    .long 0x3CFC1000  # 0.030769348145 2
+    .long 0x3D3BA000  # 0.045806884766 3
+    .long 0x3D785000  # 0.060623168945 4
+    .long 0x3D9A0000  # 0.075195312500 5
+    .long 0x3DB78000  # 0.089599609375 6
+    .long 0x3DD49000  # 0.103790283203 7
+    .long 0x3DF13000  # 0.117767333984 8
+    .long 0x3E06B000  # 0.131530761719 9
+    .long 0x3E14A000  # 0.145141601563 10
+    .long 0x3E226000  # 0.158569335938 11
+    .long 0x3E2FF000  # 0.171813964844 12
+    .long 0x3E3D5000  # 0.184875488281 13
+    .long 0x3E4A9000  # 0.197814941406 14
+    .long 0x3E579000  # 0.210510253906 15
+    .long 0x3E647000  # 0.223083496094 16
+    .long 0x3E713000  # 0.235534667969 17
+    .long 0x3E7DC000  # 0.247802734375 18
+    .long 0x3E851000  # 0.259887695313 19
+    .long 0x3E8B3000  # 0.271850585938 20
+    .long 0x3E914000  # 0.283691406250 21
+    .long 0x3E974000  # 0.295410156250 22
+    .long 0x3E9D3000  # 0.307006835938 23
+    .long 0x3EA30000  # 0.318359375000 24
+    .long 0x3EA8D000  # 0.329711914063 25
+    .long 0x3EAE8000  # 0.340820312500 26
+    .long 0x3EB43000  # 0.351928710938 27
+    .long 0x3EB9C000  # 0.362792968750 28
+    .long 0x3EBF5000  # 0.373657226563 29
+    .long 0x3EC4D000  # 0.384399414063 30
+    .long 0x3ECA3000  # 0.394897460938 31
+    .long 0x3ECF9000  # 0.405395507813 32
+    .long 0x3ED4E000  # 0.415771484375 33
+    .long 0x3EDA2000  # 0.426025390625 34
+    .long 0x3EDF5000  # 0.436157226563 35
+    .long 0x3EE47000  # 0.446166992188 36
+    .long 0x3EE99000  # 0.456176757813 37
+    .long 0x3EEEA000  # 0.466064453125 38
+    .long 0x3EF3A000  # 0.475830078125 39
+    .long 0x3EF89000  # 0.485473632813 40
+    .long 0x3EFD7000  # 0.494995117188 41
+    .long 0x3F012000  # 0.504394531250 42
+    .long 0x3F039000  # 0.513916015625 43
+    .long 0x3F05F000  # 0.523193359375 44
+    .long 0x3F084000  # 0.532226562500 45
+    .long 0x3F0AA000  # 0.541503906250 46
+    .long 0x3F0CF000  # 0.550537109375 47
+    .long 0x3F0F4000  # 0.559570312500 48
+    .long 0x3F118000  # 0.568359375000 49
+    .long 0x3F13C000  # 0.577148437500 50
+    .long 0x3F160000  # 0.585937500000 51
+    .long 0x3F183000  # 0.594482421875 52
+    .long 0x3F1A7000  # 0.603271484375 53
+    .long 0x3F1C9000  # 0.611572265625 54
+    .long 0x3F1EC000  # 0.620117187500 55
+    .long 0x3F20E000  # 0.628417968750 56
+    .long 0x3F230000  # 0.636718750000 57
+    .long 0x3F252000  # 0.645019531250 58
+    .long 0x3F273000  # 0.653076171875 59
+    .long 0x3F295000  # 0.661376953125 60
+    .long 0x3F2B5000  # 0.669189453125 61
+    .long 0x3F2D6000  # 0.677246093750 62
+    .long 0x3F2F7000  # 0.685302734375 63
+    .long 0x3F317000  # 0.693115234375 64
+    .long 0					# for alignment
+
+.L__np_ln_tail_table:
+    .long 0x00000000  # 0.000000000000 0
+    .long 0x35A8B0FC  # 0.000001256848 1
+    .long 0x361B0E78  # 0.000002310522 2
+    .long 0x3631EC66  # 0.000002651266 3
+    .long 0x35C30046  # 0.000001452871 4
+    .long 0x37EBCB0E  # 0.000028108738 5
+    .long 0x37528AE5  # 0.000012549314 6
+    .long 0x36DA7496  # 0.000006510479 7
+    .long 0x3783B715  # 0.000015701671 8
+    .long 0x383F3E68  # 0.000045596069 9
+    .long 0x38297C10  # 0.000040408282 10
+    .long 0x3815B666  # 0.000035694240 11
+    .long 0x38183854  # 0.000036292084 12
+    .long 0x38448108  # 0.000046850211 13
+    .long 0x373539E9  # 0.000010801924 14
+    .long 0x3864A740  # 0.000054515200 15
+    .long 0x387BE3CD  # 0.000060055219 16
+    .long 0x3803B715  # 0.000031403342 17
+    .long 0x380C36AF  # 0.000033429529 18
+    .long 0x3892713A  # 0.000069829126 19
+    .long 0x38AE55D6  # 0.000083129547 20
+    .long 0x38A0FDE8  # 0.000076766883 21
+    .long 0x3862BAE1  # 0.000054056643 22
+    .long 0x3798AAD3  # 0.000018199358 23
+    .long 0x38C5E10E  # 0.000094356117 24
+    .long 0x382D872E  # 0.000041372310 25
+    .long 0x38DEDFAC  # 0.000106274470 26
+    .long 0x38481E9B  # 0.000047712219 27
+    .long 0x38EBFB5E  # 0.000112524940 28
+    .long 0x38783B83  # 0.000059183232 29
+    .long 0x374E1B05  # 0.000012284848 30
+    .long 0x38CA0E11  # 0.000096347307 31
+    .long 0x3891F660  # 0.000069600297 32
+    .long 0x386C9A9A  # 0.000056410769 33
+    .long 0x38777BCD  # 0.000059004688 34
+    .long 0x38A6CED4  # 0.000079540216 35
+    .long 0x38FBE3CD  # 0.000120110439 36
+    .long 0x387E7E01  # 0.000060675669 37
+    .long 0x37D40984  # 0.000025276800 38
+    .long 0x3784C3AD  # 0.000015826745 39
+    .long 0x380F5FAF  # 0.000034182969 40
+    .long 0x38AC47BC  # 0.000082149607 41
+    .long 0x392952D3  # 0.000161479504 42
+    .long 0x37F97073  # 0.000029735476 43
+    .long 0x3865C84A  # 0.000054784388 44
+    .long 0x3979CF17  # 0.000238236375 45
+    .long 0x38C3D2F5  # 0.000093376184 46
+    .long 0x38E6B468  # 0.000110008579 47
+    .long 0x383EBCE1  # 0.000045475437 48
+    .long 0x39186BDF  # 0.000145360347 49
+    .long 0x392F0945  # 0.000166927537 50
+    .long 0x38E9ED45  # 0.000111545007 51
+    .long 0x396B99A8  # 0.000224685878 52
+    .long 0x37A27674  # 0.000019367064 53
+    .long 0x397069AB  # 0.000229275480 54
+    .long 0x39013539  # 0.000123222257 55
+    .long 0x3947F423  # 0.000190690669 56
+    .long 0x3945E10E  # 0.000188712234 57
+    .long 0x38F85DB0  # 0.000118430122 58
+    .long 0x396C08DC  # 0.000225100142 59
+    .long 0x37B4996F  # 0.000021529120 60
+    .long 0x397CEADA  # 0.000241200818 61
+    .long 0x3920261B  # 0.000152729845 62
+    .long 0x35AA4906  # 0.000001268724 63
+    .long 0x3805FDF4  # 0.000031946183 64
+    .long 0					# for alignment
+
diff --git a/src/gas/vrs4log2f.S b/src/gas/vrs4log2f.S
new file mode 100644
index 0000000..05185b2
--- /dev/null
+++ b/src/gas/vrs4log2f.S
@@ -0,0 +1,639 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrs4log2f.s
+#
+# A vector implementation of the logf libm function.
+#  This routine implemented in single precision.  It is slightly
+#  less accurate than the double precision version, but it will
+#  be better for vectorizing.
+#
+# Prototype:
+#
+#     __m128 __vrs4_log2f(__m128 x);
+#
+#   Computes the natural log of x.
+#   Returns proper C99 values, but may not raise status flags properly.
+#   Less than 1 ulp of error.
+#
+#
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+        .text
+        .align 16
+        .p2align 4,,15
+
+# define local variable storage offsets
+.equ	p_x,0			# save x
+.equ	p_idx,0x010		# xmmword index
+.equ	p_z1,0x020		# xmmword index
+.equ	p_q,0x030		# xmmword index
+.equ	p_corr,0x040		# xmmword index
+.equ	p_omask,0x050		# xmmword index
+.equ	save_xmm6,0x060		#
+.equ	save_rbx,0x070		#
+
+.equ	stack_size,0x088
+
+
+
+.globl __vrs4_log2f
+    .type   __vrs4_log2f,@function
+__vrs4_log2f:
+	sub		$stack_size,%rsp
+	mov		%rbx,save_rbx(%rsp)	# save rbx
+
+# check 2 as a special case
+	movdqa	%xmm0,p_x(%rsp)	# save x
+#	movdqa	%xmm0,%xmm2
+#	cmpps	$0,.L__real_ef(%rip),%xmm2
+#	movmskps	%xmm2,%r9d
+
+#
+# compute the index into the log tables
+#
+	movdqa	%xmm0,%xmm3
+	movaps	%xmm0,%xmm1
+	psrld	$23,%xmm3
+	subps	.L__real_one(%rip),%xmm1
+	psubd	.L__mask_127(%rip),%xmm3
+	cvtdq2ps	%xmm3,%xmm6			# xexp
+
+
+	movdqa	%xmm0,%xmm3
+	pand	.L__real_mant(%rip),%xmm3
+	xor		%r8,%r8
+	movdqa	%xmm3,%xmm2
+	movaps	.L__real_half(%rip),%xmm5							# .5
+
+#/* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+	psrld	$16,%xmm3
+	lea		.L__np_ln_lead_table(%rip),%rdx
+	movdqa	%xmm3,%xmm4
+	psrld	$1,%xmm3
+	paddd	.L__mask_040(%rip),%xmm3
+	pand	.L__mask_001(%rip),%xmm4
+	paddd	%xmm4,%xmm3
+	cvtdq2ps	%xmm3,%xmm1
+	packssdw	%xmm3,%xmm3
+	movq	%xmm3,p_idx(%rsp)
+
+
+# reduce and get u
+	movdqa	%xmm0,%xmm3
+	orps		.L__real_half(%rip),%xmm2
+
+
+	mulps	.L__real_3c000000(%rip),%xmm1				# f1 = index/128
+
+
+	subps	%xmm1,%xmm2											# f2 = f - f1
+	mulps	%xmm2,%xmm5
+	addps	%xmm5,%xmm1
+
+	divps	%xmm1,%xmm2				# u
+
+	mov		p_idx(%rsp),%rcx 			# get the indexes
+	mov		%cx,%r8w
+	ror		$16,%rcx
+	mov		-256(%rdx,%r8,4),%eax		# get the f1 value
+
+	mov		%cx,%r8w
+	ror		$16,%rcx
+	mov		-256(%rdx,%r8,4),%ebx		# get the f1 value
+	shl		$32,%rbx
+	or		%rbx,%rax
+	mov		 %rax,p_z1(%rsp) 			# save the f1 values
+
+	mov		%cx,%r8w
+	ror		$16,%rcx
+	mov		-256(%rdx,%r8,4),%eax		# get the f1 value
+
+	mov		%cx,%r8w
+	ror		$16,%rcx
+	or		-256(%rdx,%r8,4),%ebx		# get the f1 value
+	shl		$32,%rbx
+	or		%rbx,%rax
+	mov		 %rax,p_z1+8(%rsp) 			# save the f1 value
+
+# solve for ln(1+u)
+	movaps	%xmm2,%xmm1				# u
+	mulps	%xmm2,%xmm2				# u^2
+	movaps	%xmm2,%xmm5
+	lea		.L__np_ln_tail_table(%rip),%rdx
+	movaps	.L__real_cb3(%rip),%xmm3
+	mulps	%xmm2,%xmm3				#Cu2
+	mulps	%xmm1,%xmm5				# u^3
+	addps	.L__real_cb2(%rip),%xmm3 #B+Cu2
+	movaps	%xmm2,%xmm4
+	mulps	%xmm5,%xmm4				# u^5
+	movaps	.L__real_log2_lead(%rip),%xmm2
+	movaps	.L__real_log2e_lead(%rip),%xmm2
+
+	mulps	.L__real_cb1(%rip),%xmm5 #Au3
+	addps	%xmm5,%xmm1				# u+Au3
+	mulps	%xmm3,%xmm4				# u5(B+Cu2)
+	movaps	.L__real_log2e_tail(%rip),%xmm3
+	addps	%xmm4,%xmm1				# poly
+
+# recombine
+	mov		%cx,%r8w
+	shr		$16,%rcx
+	mov		-256(%rdx,%r8,4),%eax		# get the f1 value
+
+	mov		%cx,%r8w
+	shr		$16,%rcx
+	or		-256(%rdx,%r8,4),%ebx		# get the f1 value
+	shl		$32,%rbx
+	or		%rbx,%rax
+	mov		 %rax,p_q(%rsp) 			# save the f1 value
+
+	mov		%cx,%r8w
+	shr		$16,%rcx
+	mov		-256(%rdx,%r8,4),%eax		# get the f1 value
+
+	mov		%cx,%r8w
+	mov		-256(%rdx,%r8,4),%ebx		# get the f1 value
+	shl		$32,%rbx
+	or		%rbx,%rax
+	mov		 %rax,p_q+8(%rsp) 			# save the f1 value
+
+	addps	p_q(%rsp),%xmm1 #z2	+=q
+	movaps	%xmm1,%xmm4	#z2 copy
+	movaps	p_z1(%rsp),%xmm0			# z1  values
+	movaps	%xmm0,%xmm5	#z1 copy
+	mulps	%xmm2,%xmm5	#z1*log2e_lead
+	mulps	%xmm2,%xmm1	#z2*log2e_lead
+	mulps	%xmm3,%xmm4	#z2*log2e_tail
+	mulps	%xmm3,%xmm0	#z1*log2e_tail
+	addps	%xmm6,%xmm5	#r1 = z1*log2e_lead + xexp
+	addps	%xmm4,%xmm0	#z1*log2e_tail + z2*log2e_tail
+	addps	%xmm1,%xmm0	#r2
+#return r1+r2
+	addps 	%xmm5,%xmm0	# r1+ r2
+# check for e
+#	test		$0x0f,%r9d
+#	jnz			.L__vlogf_e
+.L__f1:
+
+# check for negative numbers or zero
+	xorps	%xmm1,%xmm1
+	cmpps	$1,p_x(%rsp),%xmm1	# 0 greater than =?. catches NaNs also.
+	movmskps	%xmm1,%r9d
+	cmp		$0x0f,%r9d
+	jnz		.L__z_or_neg
+
+.L__f2:
+##  if +inf
+	movaps	p_x(%rsp),%xmm3
+	cmpps	$0,.L__real_inf(%rip),%xmm3
+	movmskps	%xmm3,%r9d
+	test		$0x0f,%r9d
+	jnz		.L__log_inf
+.L__f3:
+
+	movaps	p_x(%rsp),%xmm3
+	subps	.L__real_one(%rip),%xmm3
+	andps	.L__real_notsign(%rip),%xmm3
+	cmpps	$2,.L__real_threshold(%rip),%xmm3
+	movmskps	%xmm3,%r9d
+	test	$0x0f,%r9d
+	jnz		.L__near_one
+
+
+.L__finish:
+	mov		save_rbx(%rsp),%rbx		# restore rbx
+	add		$stack_size,%rsp
+	ret
+
+.L__vlogf_e:
+	movdqa	p_x(%rsp),%xmm2
+	cmpps	$0,.L__real_ef(%rip),%xmm2
+	movdqa	%xmm2,%xmm3
+	andnps	%xmm0,%xmm3							# keep the non-e values
+	andps	.L__real_one(%rip),%xmm2			# setup the 1 values
+	orps	%xmm3,%xmm2							# merge
+	movdqa	%xmm2,%xmm0							# and replace
+	jmp		.L__f1
+
+	.align	16
+.L__near_one:
+# saves 10 cycles
+#      r = x - 1.0;
+	movdqa	%xmm3,p_omask(%rsp)	# save ones mask
+	movaps	p_x(%rsp),%xmm3
+	movaps	.L__real_two(%rip),%xmm2
+	subps	.L__real_one(%rip),%xmm3	   # r
+#      u          = r / (2.0 + r);
+	addps	%xmm3,%xmm2
+	movaps	%xmm3,%xmm1
+	divps	%xmm2,%xmm1		# u
+	movaps	.L__real_ca4(%rip),%xmm4	  #D
+	movaps	.L__real_ca3(%rip),%xmm5	  #C
+#      correction = r * u;
+	movaps	%xmm3,%xmm6
+	mulps	%xmm1,%xmm6		# correction
+	movdqa	%xmm6,p_corr(%rsp)	# save correction
+#      u          = u + u;
+	addps	%xmm1,%xmm1		#u
+	movaps	%xmm1,%xmm2
+	mulps	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulps	%xmm1,%xmm5		# Cu
+	movaps	%xmm1,%xmm6
+	mulps	%xmm2,%xmm6		# u^3
+	mulps	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulps	%xmm6,%xmm4		#Du^3
+
+	addps	.L__real_ca1(%rip),%xmm2	# +A
+	movaps	%xmm6,%xmm1
+	mulps	%xmm1,%xmm1		# u^6
+	addps	%xmm4,%xmm5		#Cu+Du3
+
+	mulps	%xmm6,%xmm2		#u3(A+Bu2)
+	mulps	%xmm5,%xmm1		#u6(Cu+Du3)
+	addps	%xmm1,%xmm2
+	subps	p_corr(%rsp),%xmm2		# -correction
+
+	movaps  %xmm3,%xmm5 	#r1=r
+	pand 	.L__mask_lower(%rip),%xmm5
+	subps	%xmm5,%xmm3
+	addps	%xmm3,%xmm2	#r2 = r2 + (r-r1)
+
+	movaps	%xmm5,%xmm3
+	movaps	%xmm2,%xmm1
+
+	mulps 	.L__real_log2e_tail(%rip),%xmm2
+	mulps 	.L__real_log2e_tail(%rip),%xmm3
+	mulps 	.L__real_log2e_lead(%rip),%xmm1
+	mulps 	.L__real_log2e_lead(%rip),%xmm5
+	addps 	%xmm2,%xmm3
+	addps 	%xmm1,%xmm3
+	addps	%xmm5,%xmm3
+#      return r + r2;
+#	addps	%xmm2,%xmm3
+
+	movdqa	p_omask(%rsp),%xmm6
+	movdqa	%xmm6,%xmm2
+	andnps	%xmm0,%xmm6					# keep the non-nearone values
+	andps	%xmm3,%xmm2					# setup the nearone values
+	orps	%xmm6,%xmm2					# merge
+	movdqa	%xmm2,%xmm0					# and replace
+
+	jmp		.L__finish
+
+# we have a zero, a negative number, or both.
+# the mask is already in .LNaNs,%xmm1 are also picked up here, along with -inf.
+.L__z_or_neg:
+# deal with negatives first
+	movdqa	%xmm1,%xmm3
+	andps	%xmm0,%xmm3							# keep the non-error values
+	andnps	.L__real_nan(%rip),%xmm1			# setup the nan values
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+# check for +/- 0
+	xorps	%xmm1,%xmm1
+	cmpps	$0,p_x(%rsp),%xmm1	# 0 ?.
+	movmskps	%xmm1,%r9d
+	test		$0x0f,%r9d
+	jz		.L__zn2
+
+	movdqa	%xmm1,%xmm3
+	andnps	%xmm0,%xmm3							# keep the non-error values
+	andps	.L__real_ninf(%rip),%xmm1		# ; C99 specs -inf for +-0
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+
+.L__zn2:
+# check for NaNs
+	movaps	p_x(%rsp),%xmm3
+	andps	.L__real_inf(%rip),%xmm3
+	cmpps	$0,.L__real_inf(%rip),%xmm3		# mask for max exponent
+
+	movdqa	p_x(%rsp),%xmm4
+	pand	.L__real_mant(%rip),%xmm4		# mask for non-zero mantissa
+	pcmpeqd	.L__real_zero(%rip),%xmm4
+	pandn	%xmm3,%xmm4							# mask for NaNs
+	movdqa	%xmm4,%xmm2
+	movdqa	p_x(%rsp),%xmm1			# isolate the NaNs
+	pand	%xmm4,%xmm1
+
+	pand	.L__real_qnanbit(%rip),%xmm4		# now we have a mask that will set QNaN bit
+	por		%xmm1,%xmm4							# turn SNaNs to QNaNs
+
+	movdqa	%xmm2,%xmm1
+	andnps	%xmm0,%xmm2							# keep the non-error values
+	orps	%xmm4,%xmm2							# merge
+	movdqa	%xmm2,%xmm0							# and replace
+	xorps	%xmm4,%xmm4
+
+	jmp		.L__f2
+
+# handle only +inf	 log(+inf) = inf
+.L__log_inf:
+	movdqa	%xmm3,%xmm1
+	andnps	%xmm0,%xmm3							# keep the non-error values
+	andps	p_x(%rsp),%xmm1			# setup the +inf values
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+	jmp		.L__f3
+
+
+        .data
+        .align 64
+
+.L__real_zero:				.quad 0x00000000000000000	# 1.0
+					.quad 0x00000000000000000
+.L__real_one:				.quad 0x03f8000003f800000	# 1.0
+					.quad 0x03f8000003f800000
+.L__real_two:				.quad 0x04000000040000000	# 1.0
+					.quad 0x04000000040000000
+.L__real_ninf:				.quad 0x0ff800000ff800000	# -inf
+					.quad 0x0ff800000ff800000
+.L__real_inf:				.quad 0x07f8000007f800000	# +inf
+					.quad 0x07f8000007f800000
+.L__real_nan:				.quad 0x07fc000007fc00000	# NaN
+					.quad 0x07fc000007fc00000
+.L__real_ef:				.quad 0x0402DF854402DF854	# float e
+					.quad 0x0402DF854402DF854
+
+.L__real_sign:				.quad 0x08000000080000000	# sign bit
+					.quad 0x08000000080000000
+.L__real_notsign:			.quad 0x07ffFFFFF7ffFFFFF	# ^sign bit
+					.quad 0x07ffFFFFF7ffFFFFF
+.L__real_qnanbit:			.quad 0x00040000000400000	# quiet nan bit
+					.quad 0x00040000000400000
+.L__real_mant:				.quad 0x0007FFFFF007FFFFF	# mantipsa bits
+					.quad 0x0007FFFFF007FFFFF
+.L__real_3c000000:			.quad 0x03c0000003c000000	# /* 0.0078125 = 1/128 */
+					.quad 0x03c0000003c000000
+.L__mask_127:				.quad 0x00000007f0000007f	#
+					.quad 0x00000007f0000007f
+.L__mask_040:				.quad 0x00000004000000040	#
+					.quad 0x00000004000000040
+.L__mask_001:				.quad 0x00000000100000001	#
+					.quad 0x00000000100000001
+
+
+.L__real_threshold:			.quad 0x03CF5C28F3CF5C28F	# .03
+					.quad 0x03CF5C28F3CF5C28F
+
+.L__real_ca1:				.quad 0x03DAAAAAB3DAAAAAB	# 8.33333333333317923934e-02
+					.quad 0x03DAAAAAB3DAAAAAB
+.L__real_ca2:				.quad 0x03C4CCCCD3C4CCCCD	# 1.25000000037717509602e-02
+					.quad 0x03C4CCCCD3C4CCCCD
+.L__real_ca3:				.quad 0x03B1249183B124918	# 2.23213998791944806202e-03
+					.quad 0x03B1249183B124918
+.L__real_ca4:				.quad 0x039E401A639E401A6	# 4.34887777707614552256e-04
+					.quad 0x039E401A639E401A6
+.L__real_cb1:				.quad 0x03DAAAAAB3DAAAAAB	# 8.33333333333333593622e-02
+					.quad 0x03DAAAAAB3DAAAAAB
+.L__real_cb2:				.quad 0x03C4CCCCD3C4CCCCD	# 1.24999999978138668903e-02
+					.quad 0x03C4CCCCD3C4CCCCD
+.L__real_cb3:				.quad 0x03B124A123B124A12	# 2.23219810758559851206e-03
+					.quad 0x03B124A123B124A12
+.L__real_log2_lead:        		.quad 0x03F3170003F317000  # 0.693115234375
+                        		.quad 0x03F3170003F317000
+.L__real_log2_tail:        		.quad 0x03805FDF43805FDF4  # 0.000031946183
+                        		.quad 0x03805FDF43805FDF4
+.L__real_half:				.quad 0x03f0000003f000000	# 1/2
+					.quad 0x03f0000003f000000
+.L__real_log2e_lead:       .quad 0x03FB800003FB80000  #1.4375000000
+                        .quad 0x03FB800003FB80000
+.L__real_log2e_tail:       .quad 0x03BAA3B293BAA3B29  # 0.0051950408889633
+                        .quad 0x03BAA3B293BAA3B29
+
+.L__mask_lower:			.quad 0x0ffff0000ffff0000	#
+						.quad 0x0ffff0000ffff0000
+
+.L__np_ln__table:
+	.quad	0x0000000000000000 		# 0.00000000000000000000e+00
+	.quad	0x3F8FC0A8B0FC03E4		# 1.55041813850402832031e-02
+	.quad	0x3F9F829B0E783300		# 3.07716131210327148438e-02
+	.quad	0x3FA77458F632DCFC		# 4.58095073699951171875e-02
+	.quad	0x3FAF0A30C01162A6		# 6.06245994567871093750e-02
+	.quad	0x3FB341D7961BD1D1		# 7.52233862876892089844e-02
+	.quad	0x3FB6F0D28AE56B4C		# 8.96121263504028320312e-02
+	.quad	0x3FBA926D3A4AD563		# 1.03796780109405517578e-01
+	.quad	0x3FBE27076E2AF2E6		# 1.17783010005950927734e-01
+	.quad	0x3FC0D77E7CD08E59		# 1.31576299667358398438e-01
+	.quad	0x3FC29552F81FF523		# 1.45181953907012939453e-01
+	.quad	0x3FC44D2B6CCB7D1E		# 1.58604979515075683594e-01
+	.quad	0x3FC5FF3070A793D4		# 1.71850204467773437500e-01
+	.quad	0x3FC7AB890210D909		# 1.84922337532043457031e-01
+	.quad	0x3FC9525A9CF456B4		# 1.97825729846954345703e-01
+	.quad	0x3FCAF3C94E80BFF3		# 2.10564732551574707031e-01
+	.quad	0x3FCC8FF7C79A9A22		# 2.23143517971038818359e-01
+	.quad	0x3FCE27076E2AF2E6		# 2.35566020011901855469e-01
+	.quad	0x3FCFB9186D5E3E2B		# 2.47836112976074218750e-01
+	.quad	0x3FD0A324E27390E3		# 2.59957492351531982422e-01
+	.quad	0x3FD1675CABABA60E		# 2.71933674812316894531e-01
+	.quad	0x3FD22941FBCF7966		# 2.83768117427825927734e-01
+	.quad	0x3FD2E8E2BAE11D31		# 2.95464158058166503906e-01
+	.quad	0x3FD3A64C556945EA		# 3.07025015354156494141e-01
+	.quad	0x3FD4618BC21C5EC2		# 3.18453729152679443359e-01
+	.quad	0x3FD51AAD872DF82D		# 3.29753279685974121094e-01
+	.quad	0x3FD5D1BDBF5809CA		# 3.40926527976989746094e-01
+	.quad	0x3FD686C81E9B14AF		# 3.51976394653320312500e-01
+	.quad	0x3FD739D7F6BBD007		# 3.62905442714691162109e-01
+	.quad	0x3FD7EAF83B82AFC3		# 3.73716354370117187500e-01
+	.quad	0x3FD89A3386C1425B		# 3.84411692619323730469e-01
+	.quad	0x3FD947941C2116FB		# 3.94993782043457031250e-01
+	.quad	0x3FD9F323ECBF984C		# 4.05465066432952880859e-01
+	.quad	0x3FDA9CEC9A9A084A		# 4.15827870368957519531e-01
+	.quad	0x3FDB44F77BCC8F63		# 4.26084339618682861328e-01
+	.quad	0x3FDBEB4D9DA71B7C		# 4.36236739158630371094e-01
+	.quad	0x3FDC8FF7C79A9A22		# 4.46287095546722412109e-01
+	.quad	0x3FDD32FE7E00EBD5		# 4.56237375736236572266e-01
+	.quad	0x3FDDD46A04C1C4A1		# 4.66089725494384765625e-01
+	.quad	0x3FDE744261D68788		# 4.75845873355865478516e-01
+	.quad	0x3FDF128F5FAF06ED		# 4.85507786273956298828e-01
+	.quad	0x3FDFAF588F78F31F		# 4.95077252388000488281e-01
+	.quad	0x3FE02552A5A5D0FF		# 5.04556000232696533203e-01
+	.quad	0x3FE0723E5C1CDF40		# 5.13945698738098144531e-01
+	.quad	0x3FE0BE72E4252A83		# 5.23248136043548583984e-01
+	.quad	0x3FE109F39E2D4C97		# 5.32464742660522460938e-01
+	.quad	0x3FE154C3D2F4D5EA		# 5.41597247123718261719e-01
+	.quad	0x3FE19EE6B467C96F		# 5.50647079944610595703e-01
+	.quad	0x3FE1E85F5E7040D0		# 5.59615731239318847656e-01
+	.quad	0x3FE23130D7BEBF43		# 5.68504691123962402344e-01
+	.quad	0x3FE2795E1289B11B		# 5.77315330505371093750e-01
+	.quad	0x3FE2C0E9ED448E8C		# 5.86049020290374755859e-01
+	.quad	0x3FE307D7334F10BE		# 5.94707071781158447266e-01
+	.quad	0x3FE34E289D9CE1D3		# 6.03290796279907226562e-01
+	.quad	0x3FE393E0D3562A1A		# 6.11801505088806152344e-01
+	.quad	0x3FE3D9026A7156FB		# 6.20240390300750732422e-01
+	.quad	0x3FE41D8FE84672AE		# 6.28608644008636474609e-01
+	.quad	0x3FE4618BC21C5EC2		# 6.36907458305358886719e-01
+	.quad	0x3FE4A4F85DB03EBB		# 6.45137906074523925781e-01
+	.quad	0x3FE4E7D811B75BB1		# 6.53301239013671875000e-01
+	.quad	0x3FE52A2D265BC5AB		# 6.61398470401763916016e-01
+	.quad	0x3FE56BF9D5B3F399		# 6.69430613517761230469e-01
+	.quad	0x3FE5AD404C359F2D		# 6.77398800849914550781e-01
+	.quad	0x3FE5EE02A9241675		# 6.85303986072540283203e-01
+	.quad	0x3FE62E42FEFA39EF		# 6.93147122859954833984e-01
+	.quad 0					# for alignment
+
+.L__np_ln_lead_table:
+    .long 0x00000000  # 0.000000000000 0
+    .long 0x3C7E0000  # 0.015502929688 1
+    .long 0x3CFC1000  # 0.030769348145 2
+    .long 0x3D3BA000  # 0.045806884766 3
+    .long 0x3D785000  # 0.060623168945 4
+    .long 0x3D9A0000  # 0.075195312500 5
+    .long 0x3DB78000  # 0.089599609375 6
+    .long 0x3DD49000  # 0.103790283203 7
+    .long 0x3DF13000  # 0.117767333984 8
+    .long 0x3E06B000  # 0.131530761719 9
+    .long 0x3E14A000  # 0.145141601563 10
+    .long 0x3E226000  # 0.158569335938 11
+    .long 0x3E2FF000  # 0.171813964844 12
+    .long 0x3E3D5000  # 0.184875488281 13
+    .long 0x3E4A9000  # 0.197814941406 14
+    .long 0x3E579000  # 0.210510253906 15
+    .long 0x3E647000  # 0.223083496094 16
+    .long 0x3E713000  # 0.235534667969 17
+    .long 0x3E7DC000  # 0.247802734375 18
+    .long 0x3E851000  # 0.259887695313 19
+    .long 0x3E8B3000  # 0.271850585938 20
+    .long 0x3E914000  # 0.283691406250 21
+    .long 0x3E974000  # 0.295410156250 22
+    .long 0x3E9D3000  # 0.307006835938 23
+    .long 0x3EA30000  # 0.318359375000 24
+    .long 0x3EA8D000  # 0.329711914063 25
+    .long 0x3EAE8000  # 0.340820312500 26
+    .long 0x3EB43000  # 0.351928710938 27
+    .long 0x3EB9C000  # 0.362792968750 28
+    .long 0x3EBF5000  # 0.373657226563 29
+    .long 0x3EC4D000  # 0.384399414063 30
+    .long 0x3ECA3000  # 0.394897460938 31
+    .long 0x3ECF9000  # 0.405395507813 32
+    .long 0x3ED4E000  # 0.415771484375 33
+    .long 0x3EDA2000  # 0.426025390625 34
+    .long 0x3EDF5000  # 0.436157226563 35
+    .long 0x3EE47000  # 0.446166992188 36
+    .long 0x3EE99000  # 0.456176757813 37
+    .long 0x3EEEA000  # 0.466064453125 38
+    .long 0x3EF3A000  # 0.475830078125 39
+    .long 0x3EF89000  # 0.485473632813 40
+    .long 0x3EFD7000  # 0.494995117188 41
+    .long 0x3F012000  # 0.504394531250 42
+    .long 0x3F039000  # 0.513916015625 43
+    .long 0x3F05F000  # 0.523193359375 44
+    .long 0x3F084000  # 0.532226562500 45
+    .long 0x3F0AA000  # 0.541503906250 46
+    .long 0x3F0CF000  # 0.550537109375 47
+    .long 0x3F0F4000  # 0.559570312500 48
+    .long 0x3F118000  # 0.568359375000 49
+    .long 0x3F13C000  # 0.577148437500 50
+    .long 0x3F160000  # 0.585937500000 51
+    .long 0x3F183000  # 0.594482421875 52
+    .long 0x3F1A7000  # 0.603271484375 53
+    .long 0x3F1C9000  # 0.611572265625 54
+    .long 0x3F1EC000  # 0.620117187500 55
+    .long 0x3F20E000  # 0.628417968750 56
+    .long 0x3F230000  # 0.636718750000 57
+    .long 0x3F252000  # 0.645019531250 58
+    .long 0x3F273000  # 0.653076171875 59
+    .long 0x3F295000  # 0.661376953125 60
+    .long 0x3F2B5000  # 0.669189453125 61
+    .long 0x3F2D6000  # 0.677246093750 62
+    .long 0x3F2F7000  # 0.685302734375 63
+    .long 0x3F317000  # 0.693115234375 64
+    .long 0					# for alignment
+
+.L__np_ln_tail_table:
+    .long 0x00000000  # 0.000000000000 0
+    .long 0x35A8B0FC  # 0.000001256848 1
+    .long 0x361B0E78  # 0.000002310522 2
+    .long 0x3631EC66  # 0.000002651266 3
+    .long 0x35C30046  # 0.000001452871 4
+    .long 0x37EBCB0E  # 0.000028108738 5
+    .long 0x37528AE5  # 0.000012549314 6
+    .long 0x36DA7496  # 0.000006510479 7
+    .long 0x3783B715  # 0.000015701671 8
+    .long 0x383F3E68  # 0.000045596069 9
+    .long 0x38297C10  # 0.000040408282 10
+    .long 0x3815B666  # 0.000035694240 11
+    .long 0x38183854  # 0.000036292084 12
+    .long 0x38448108  # 0.000046850211 13
+    .long 0x373539E9  # 0.000010801924 14
+    .long 0x3864A740  # 0.000054515200 15
+    .long 0x387BE3CD  # 0.000060055219 16
+    .long 0x3803B715  # 0.000031403342 17
+    .long 0x380C36AF  # 0.000033429529 18
+    .long 0x3892713A  # 0.000069829126 19
+    .long 0x38AE55D6  # 0.000083129547 20
+    .long 0x38A0FDE8  # 0.000076766883 21
+    .long 0x3862BAE1  # 0.000054056643 22
+    .long 0x3798AAD3  # 0.000018199358 23
+    .long 0x38C5E10E  # 0.000094356117 24
+    .long 0x382D872E  # 0.000041372310 25
+    .long 0x38DEDFAC  # 0.000106274470 26
+    .long 0x38481E9B  # 0.000047712219 27
+    .long 0x38EBFB5E  # 0.000112524940 28
+    .long 0x38783B83  # 0.000059183232 29
+    .long 0x374E1B05  # 0.000012284848 30
+    .long 0x38CA0E11  # 0.000096347307 31
+    .long 0x3891F660  # 0.000069600297 32
+    .long 0x386C9A9A  # 0.000056410769 33
+    .long 0x38777BCD  # 0.000059004688 34
+    .long 0x38A6CED4  # 0.000079540216 35
+    .long 0x38FBE3CD  # 0.000120110439 36
+    .long 0x387E7E01  # 0.000060675669 37
+    .long 0x37D40984  # 0.000025276800 38
+    .long 0x3784C3AD  # 0.000015826745 39
+    .long 0x380F5FAF  # 0.000034182969 40
+    .long 0x38AC47BC  # 0.000082149607 41
+    .long 0x392952D3  # 0.000161479504 42
+    .long 0x37F97073  # 0.000029735476 43
+    .long 0x3865C84A  # 0.000054784388 44
+    .long 0x3979CF17  # 0.000238236375 45
+    .long 0x38C3D2F5  # 0.000093376184 46
+    .long 0x38E6B468  # 0.000110008579 47
+    .long 0x383EBCE1  # 0.000045475437 48
+    .long 0x39186BDF  # 0.000145360347 49
+    .long 0x392F0945  # 0.000166927537 50
+    .long 0x38E9ED45  # 0.000111545007 51
+    .long 0x396B99A8  # 0.000224685878 52
+    .long 0x37A27674  # 0.000019367064 53
+    .long 0x397069AB  # 0.000229275480 54
+    .long 0x39013539  # 0.000123222257 55
+    .long 0x3947F423  # 0.000190690669 56
+    .long 0x3945E10E  # 0.000188712234 57
+    .long 0x38F85DB0  # 0.000118430122 58
+    .long 0x396C08DC  # 0.000225100142 59
+    .long 0x37B4996F  # 0.000021529120 60
+    .long 0x397CEADA  # 0.000241200818 61
+    .long 0x3920261B  # 0.000152729845 62
+    .long 0x35AA4906  # 0.000001268724 63
+    .long 0x3805FDF4  # 0.000031946183 64
+    .long 0					# for alignment
+
diff --git a/src/gas/vrs4logf.S b/src/gas/vrs4logf.S
new file mode 100644
index 0000000..4a39f1c
--- /dev/null
+++ b/src/gas/vrs4logf.S
@@ -0,0 +1,614 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrs4logf.s
+#
+# A vector implementation of the logf libm function.
+#  This routine implemented in single precision.  It is slightly
+#  less accurate than the double precision version, but it will
+#  be better for vectorizing.
+#
+# Prototype:
+#
+#     __m128 __vrs4_logf(__m128 x);
+#
+#   Computes the natural log of x.
+#   Returns proper C99 values, but may not raise status flags properly.
+#   Less than 1 ulp of error.
+#
+#
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+        .text
+        .align 16
+        .p2align 4,,15
+
+# define local variable storage offsets
+.equ	p_x,0			# save x
+.equ	p_idx,0x010		# xmmword index
+.equ	p_z1,0x020		# xmmword index
+.equ	p_q,0x030		# xmmword index
+.equ	p_corr,0x040		# xmmword index
+.equ	p_omask,0x050		# xmmword index
+.equ	save_xmm6,0x060		#
+.equ	save_rbx,0x070		#
+
+.equ	stack_size,0x088
+
+
+
+.globl __vrs4_logf
+    .type   __vrs4_logf,@function
+__vrs4_logf:
+	sub		$stack_size,%rsp
+	mov		%rbx,save_rbx(%rsp)	# save rbx
+
+# check e as a special case
+	movdqa	%xmm0,p_x(%rsp)	# save x
+	movdqa	%xmm0,%xmm2
+	cmpps	$0,.L__real_ef(%rip),%xmm2
+	movmskps	%xmm2,%r9d
+
+#
+# compute the index into the log tables
+#
+	movdqa	%xmm0,%xmm3
+	movaps	%xmm0,%xmm1
+	psrld	$23,%xmm3
+	subps	.L__real_one(%rip),%xmm1
+	psubd	.L__mask_127(%rip),%xmm3
+	cvtdq2ps	%xmm3,%xmm6			# xexp
+
+
+	movdqa	%xmm0,%xmm3
+	pand	.L__real_mant(%rip),%xmm3
+	xor		%r8,%r8
+	movdqa	%xmm3,%xmm2
+	movaps	.L__real_half(%rip),%xmm5							# .5
+
+#/* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+	psrld	$16,%xmm3
+	lea		.L__np_ln_lead_table(%rip),%rdx
+	movdqa	%xmm3,%xmm4
+	psrld	$1,%xmm3
+	paddd	.L__mask_040(%rip),%xmm3
+	pand	.L__mask_001(%rip),%xmm4
+	paddd	%xmm4,%xmm3
+	cvtdq2ps	%xmm3,%xmm1
+	packssdw	%xmm3,%xmm3
+	movq	%xmm3,p_idx(%rsp)
+
+
+# reduce and get u
+	movdqa	%xmm0,%xmm3
+	orps		.L__real_half(%rip),%xmm2
+
+
+	mulps	.L__real_3c000000(%rip),%xmm1				# f1 = index/128
+
+
+	subps	%xmm1,%xmm2											# f2 = f - f1
+	mulps	%xmm2,%xmm5
+	addps	%xmm5,%xmm1
+
+	divps	%xmm1,%xmm2				# u
+
+	mov		p_idx(%rsp),%rcx 			# get the indexes
+	mov		%cx,%r8w
+	ror		$16,%rcx
+	mov		-256(%rdx,%r8,4),%eax		# get the f1 value
+
+	mov		%cx,%r8w
+	ror		$16,%rcx
+	mov		-256(%rdx,%r8,4),%ebx		# get the f1 value
+	shl		$32,%rbx
+	or		%rbx,%rax
+	mov		 %rax,p_z1(%rsp) 			# save the f1 values
+
+	mov		%cx,%r8w
+	ror		$16,%rcx
+	mov		-256(%rdx,%r8,4),%eax		# get the f1 value
+
+	mov		%cx,%r8w
+	ror		$16,%rcx
+	or		-256(%rdx,%r8,4),%ebx		# get the f1 value
+	shl		$32,%rbx
+	or		%rbx,%rax
+	mov		 %rax,p_z1+8(%rsp) 			# save the f1 value
+
+# solve for ln(1+u)
+	movaps	%xmm2,%xmm1				# u
+	mulps	%xmm2,%xmm2				# u^2
+	movaps	%xmm2,%xmm5
+	lea		.L__np_ln_tail_table(%rip),%rdx
+	movaps	.L__real_cb3(%rip),%xmm3
+	mulps	%xmm2,%xmm3				#Cu2
+	mulps	%xmm1,%xmm5				# u^3
+	addps	.L__real_cb2(%rip),%xmm3 #B+Cu2
+	movaps	%xmm2,%xmm4
+	mulps	%xmm5,%xmm4				# u^5
+	movaps	.L__real_log2_lead(%rip),%xmm2
+
+	mulps	.L__real_cb1(%rip),%xmm5 #Au3
+	addps	%xmm5,%xmm1				# u+Au3
+	mulps	%xmm3,%xmm4				# u5(B+Cu2)
+
+	addps	%xmm4,%xmm1				# poly
+
+# recombine
+	mov		%cx,%r8w
+	shr		$16,%rcx
+	mov		-256(%rdx,%r8,4),%eax		# get the f1 value
+
+	mov		%cx,%r8w
+	shr		$16,%rcx
+	or		-256(%rdx,%r8,4),%ebx		# get the f1 value
+	shl		$32,%rbx
+	or		%rbx,%rax
+	mov		 %rax,p_q(%rsp) 			# save the f1 value
+
+	mov		%cx,%r8w
+	shr		$16,%rcx
+	mov		-256(%rdx,%r8,4),%eax		# get the f1 value
+
+	mov		%cx,%r8w
+	mov		-256(%rdx,%r8,4),%ebx		# get the f1 value
+	shl		$32,%rbx
+	or		%rbx,%rax
+	mov		 %rax,p_q+8(%rsp) 			# save the f1 value
+
+	addps	p_q(%rsp),%xmm1 #z2	+=q
+
+	movaps	p_z1(%rsp),%xmm0			# z1  values
+
+	mulps	%xmm6,%xmm2
+	addps	%xmm2,%xmm0				#r1
+	mulps	.L__real_log2_tail(%rip),%xmm6
+	addps	%xmm6,%xmm1				#r2
+	addps	%xmm1,%xmm0
+
+# check for e
+	test		$0x0f,%r9d
+	jnz			.L__vlogf_e
+.L__f1:
+
+# check for negative numbers or zero
+	xorps	%xmm1,%xmm1
+	cmpps	$1,p_x(%rsp),%xmm1	# 0 greater than =?. catches NaNs also.
+	movmskps	%xmm1,%r9d
+	cmp		$0x0f,%r9d
+	jnz		.L__z_or_neg
+
+.L__f2:
+##  if +inf
+	movaps	p_x(%rsp),%xmm3
+	cmpps	$0,.L__real_inf(%rip),%xmm3
+	movmskps	%xmm3,%r9d
+	test		$0x0f,%r9d
+	jnz		.L__log_inf
+.L__f3:
+
+	movaps	p_x(%rsp),%xmm3
+	subps	.L__real_one(%rip),%xmm3
+	andps	.L__real_notsign(%rip),%xmm3
+	cmpps	$2,.L__real_threshold(%rip),%xmm3
+	movmskps	%xmm3,%r9d
+	test	$0x0f,%r9d
+	jnz		.L__near_one
+
+
+.L__finish:
+	mov		save_rbx(%rsp),%rbx		# restore rbx
+	add		$stack_size,%rsp
+	ret
+
+.L__vlogf_e:
+	movdqa	p_x(%rsp),%xmm2
+	cmpps	$0,.L__real_ef(%rip),%xmm2
+	movdqa	%xmm2,%xmm3
+	andnps	%xmm0,%xmm3							# keep the non-e values
+	andps	.L__real_one(%rip),%xmm2			# setup the 1 values
+	orps	%xmm3,%xmm2							# merge
+	movdqa	%xmm2,%xmm0							# and replace
+	jmp		.L__f1
+
+	.align	16
+.L__near_one:
+# saves 10 cycles
+#      r = x - 1.0;
+	movdqa	%xmm3,p_omask(%rsp)	# save ones mask
+	movaps	p_x(%rsp),%xmm3
+	movaps	.L__real_two(%rip),%xmm2
+	subps	.L__real_one(%rip),%xmm3	   # r
+#      u          = r / (2.0 + r);
+	addps	%xmm3,%xmm2
+	movaps	%xmm3,%xmm1
+	divps	%xmm2,%xmm1		# u
+	movaps	.L__real_ca4(%rip),%xmm4	  #D
+	movaps	.L__real_ca3(%rip),%xmm5	  #C
+#      correction = r * u;
+	movaps	%xmm3,%xmm6
+	mulps	%xmm1,%xmm6		# correction
+	movdqa	%xmm6,p_corr(%rsp)	# save correction
+#      u          = u + u;
+	addps	%xmm1,%xmm1		#u
+	movaps	%xmm1,%xmm2
+	mulps	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulps	%xmm1,%xmm5		# Cu
+	movaps	%xmm1,%xmm6
+	mulps	%xmm2,%xmm6		# u^3
+	mulps	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulps	%xmm6,%xmm4		#Du^3
+
+	addps	.L__real_ca1(%rip),%xmm2	# +A
+	movaps	%xmm6,%xmm1
+	mulps	%xmm1,%xmm1		# u^6
+	addps	%xmm4,%xmm5		#Cu+Du3
+
+	mulps	%xmm6,%xmm2		#u3(A+Bu2)
+	mulps	%xmm5,%xmm1		#u6(Cu+Du3)
+	addps	%xmm1,%xmm2
+	subps	p_corr(%rsp),%xmm2		# -correction
+
+#      return r + r2;
+	addps	%xmm2,%xmm3
+
+	movdqa	p_omask(%rsp),%xmm6
+	movdqa	%xmm6,%xmm2
+	andnps	%xmm0,%xmm6					# keep the non-nearone values
+	andps	%xmm3,%xmm2					# setup the nearone values
+	orps	%xmm6,%xmm2					# merge
+	movdqa	%xmm2,%xmm0					# and replace
+
+	jmp		.L__finish
+
+# we have a zero, a negative number, or both.
+# the mask is already in .LNaNs,%xmm1 are also picked up here, along with -inf.
+.L__z_or_neg:
+# deal with negatives first
+	movdqa	%xmm1,%xmm3
+	andps	%xmm0,%xmm3							# keep the non-error values
+	andnps	.L__real_nan(%rip),%xmm1			# setup the nan values
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+# check for +/- 0
+	xorps	%xmm1,%xmm1
+	cmpps	$0,p_x(%rsp),%xmm1	# 0 ?.
+	movmskps	%xmm1,%r9d
+	test		$0x0f,%r9d
+	jz		.L__zn2
+
+	movdqa	%xmm1,%xmm3
+	andnps	%xmm0,%xmm3							# keep the non-error values
+	andps	.L__real_ninf(%rip),%xmm1		# ; C99 specs -inf for +-0
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+
+.L__zn2:
+# check for NaNs
+	movaps	p_x(%rsp),%xmm3
+	andps	.L__real_inf(%rip),%xmm3
+	cmpps	$0,.L__real_inf(%rip),%xmm3		# mask for max exponent
+
+	movdqa	p_x(%rsp),%xmm4
+	pand	.L__real_mant(%rip),%xmm4		# mask for non-zero mantissa
+	pcmpeqd	.L__real_zero(%rip),%xmm4
+	pandn	%xmm3,%xmm4							# mask for NaNs
+	movdqa	%xmm4,%xmm2
+	movdqa	p_x(%rsp),%xmm1			# isolate the NaNs
+	pand	%xmm4,%xmm1
+
+	pand	.L__real_qnanbit(%rip),%xmm4		# now we have a mask that will set QNaN bit
+	por		%xmm1,%xmm4							# turn SNaNs to QNaNs
+
+	movdqa	%xmm2,%xmm1
+	andnps	%xmm0,%xmm2							# keep the non-error values
+	orps	%xmm4,%xmm2							# merge
+	movdqa	%xmm2,%xmm0							# and replace
+	xorps	%xmm4,%xmm4
+
+	jmp		.L__f2
+
+# handle only +inf	 log(+inf) = inf
+.L__log_inf:
+	movdqa	%xmm3,%xmm1
+	andnps	%xmm0,%xmm3							# keep the non-error values
+	andps	p_x(%rsp),%xmm1			# setup the +inf values
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+	jmp		.L__f3
+
+
+        .data
+        .align 64
+
+.L__real_zero:				.quad 0x00000000000000000	# 1.0
+					.quad 0x00000000000000000
+.L__real_one:				.quad 0x03f8000003f800000	# 1.0
+					.quad 0x03f8000003f800000
+.L__real_two:				.quad 0x04000000040000000	# 1.0
+					.quad 0x04000000040000000
+.L__real_ninf:				.quad 0x0ff800000ff800000	# -inf
+					.quad 0x0ff800000ff800000
+.L__real_inf:				.quad 0x07f8000007f800000	# +inf
+					.quad 0x07f8000007f800000
+.L__real_nan:				.quad 0x07fc000007fc00000	# NaN
+					.quad 0x07fc000007fc00000
+.L__real_ef:				.quad 0x0402DF854402DF854	# float e
+					.quad 0x0402DF854402DF854
+
+.L__real_sign:				.quad 0x08000000080000000	# sign bit
+					.quad 0x08000000080000000
+.L__real_notsign:			.quad 0x07ffFFFFF7ffFFFFF	# ^sign bit
+					.quad 0x07ffFFFFF7ffFFFFF
+.L__real_qnanbit:			.quad 0x00040000000400000	# quiet nan bit
+					.quad 0x00040000000400000
+.L__real_mant:				.quad 0x0007FFFFF007FFFFF	# mantipsa bits
+					.quad 0x0007FFFFF007FFFFF
+.L__real_3c000000:			.quad 0x03c0000003c000000	# /* 0.0078125 = 1/128 */
+					.quad 0x03c0000003c000000
+.L__mask_127:				.quad 0x00000007f0000007f	#
+					.quad 0x00000007f0000007f
+.L__mask_040:				.quad 0x00000004000000040	#
+					.quad 0x00000004000000040
+.L__mask_001:				.quad 0x00000000100000001	#
+					.quad 0x00000000100000001
+
+
+.L__real_threshold:			.quad 0x03CF5C28F3CF5C28F	# .03
+					.quad 0x03CF5C28F3CF5C28F
+
+.L__real_ca1:				.quad 0x03DAAAAAB3DAAAAAB	# 8.33333333333317923934e-02
+					.quad 0x03DAAAAAB3DAAAAAB
+.L__real_ca2:				.quad 0x03C4CCCCD3C4CCCCD	# 1.25000000037717509602e-02
+					.quad 0x03C4CCCCD3C4CCCCD
+.L__real_ca3:				.quad 0x03B1249183B124918	# 2.23213998791944806202e-03
+					.quad 0x03B1249183B124918
+.L__real_ca4:				.quad 0x039E401A639E401A6	# 4.34887777707614552256e-04
+					.quad 0x039E401A639E401A6
+.L__real_cb1:				.quad 0x03DAAAAAB3DAAAAAB	# 8.33333333333333593622e-02
+					.quad 0x03DAAAAAB3DAAAAAB
+.L__real_cb2:				.quad 0x03C4CCCCD3C4CCCCD	# 1.24999999978138668903e-02
+					.quad 0x03C4CCCCD3C4CCCCD
+.L__real_cb3:				.quad 0x03B124A123B124A12	# 2.23219810758559851206e-03
+					.quad 0x03B124A123B124A12
+.L__real_log2_lead:        		.quad 0x03F3170003F317000  # 0.693115234375
+                        		.quad 0x03F3170003F317000
+.L__real_log2_tail:        		.quad 0x03805FDF43805FDF4  # 0.000031946183
+                        		.quad 0x03805FDF43805FDF4
+.L__real_half:				.quad 0x03f0000003f000000	# 1/2
+					.quad 0x03f0000003f000000
+
+
+.L__np_ln__table:
+	.quad	0x0000000000000000 		# 0.00000000000000000000e+00
+	.quad	0x3F8FC0A8B0FC03E4		# 1.55041813850402832031e-02
+	.quad	0x3F9F829B0E783300		# 3.07716131210327148438e-02
+	.quad	0x3FA77458F632DCFC		# 4.58095073699951171875e-02
+	.quad	0x3FAF0A30C01162A6		# 6.06245994567871093750e-02
+	.quad	0x3FB341D7961BD1D1		# 7.52233862876892089844e-02
+	.quad	0x3FB6F0D28AE56B4C		# 8.96121263504028320312e-02
+	.quad	0x3FBA926D3A4AD563		# 1.03796780109405517578e-01
+	.quad	0x3FBE27076E2AF2E6		# 1.17783010005950927734e-01
+	.quad	0x3FC0D77E7CD08E59		# 1.31576299667358398438e-01
+	.quad	0x3FC29552F81FF523		# 1.45181953907012939453e-01
+	.quad	0x3FC44D2B6CCB7D1E		# 1.58604979515075683594e-01
+	.quad	0x3FC5FF3070A793D4		# 1.71850204467773437500e-01
+	.quad	0x3FC7AB890210D909		# 1.84922337532043457031e-01
+	.quad	0x3FC9525A9CF456B4		# 1.97825729846954345703e-01
+	.quad	0x3FCAF3C94E80BFF3		# 2.10564732551574707031e-01
+	.quad	0x3FCC8FF7C79A9A22		# 2.23143517971038818359e-01
+	.quad	0x3FCE27076E2AF2E6		# 2.35566020011901855469e-01
+	.quad	0x3FCFB9186D5E3E2B		# 2.47836112976074218750e-01
+	.quad	0x3FD0A324E27390E3		# 2.59957492351531982422e-01
+	.quad	0x3FD1675CABABA60E		# 2.71933674812316894531e-01
+	.quad	0x3FD22941FBCF7966		# 2.83768117427825927734e-01
+	.quad	0x3FD2E8E2BAE11D31		# 2.95464158058166503906e-01
+	.quad	0x3FD3A64C556945EA		# 3.07025015354156494141e-01
+	.quad	0x3FD4618BC21C5EC2		# 3.18453729152679443359e-01
+	.quad	0x3FD51AAD872DF82D		# 3.29753279685974121094e-01
+	.quad	0x3FD5D1BDBF5809CA		# 3.40926527976989746094e-01
+	.quad	0x3FD686C81E9B14AF		# 3.51976394653320312500e-01
+	.quad	0x3FD739D7F6BBD007		# 3.62905442714691162109e-01
+	.quad	0x3FD7EAF83B82AFC3		# 3.73716354370117187500e-01
+	.quad	0x3FD89A3386C1425B		# 3.84411692619323730469e-01
+	.quad	0x3FD947941C2116FB		# 3.94993782043457031250e-01
+	.quad	0x3FD9F323ECBF984C		# 4.05465066432952880859e-01
+	.quad	0x3FDA9CEC9A9A084A		# 4.15827870368957519531e-01
+	.quad	0x3FDB44F77BCC8F63		# 4.26084339618682861328e-01
+	.quad	0x3FDBEB4D9DA71B7C		# 4.36236739158630371094e-01
+	.quad	0x3FDC8FF7C79A9A22		# 4.46287095546722412109e-01
+	.quad	0x3FDD32FE7E00EBD5		# 4.56237375736236572266e-01
+	.quad	0x3FDDD46A04C1C4A1		# 4.66089725494384765625e-01
+	.quad	0x3FDE744261D68788		# 4.75845873355865478516e-01
+	.quad	0x3FDF128F5FAF06ED		# 4.85507786273956298828e-01
+	.quad	0x3FDFAF588F78F31F		# 4.95077252388000488281e-01
+	.quad	0x3FE02552A5A5D0FF		# 5.04556000232696533203e-01
+	.quad	0x3FE0723E5C1CDF40		# 5.13945698738098144531e-01
+	.quad	0x3FE0BE72E4252A83		# 5.23248136043548583984e-01
+	.quad	0x3FE109F39E2D4C97		# 5.32464742660522460938e-01
+	.quad	0x3FE154C3D2F4D5EA		# 5.41597247123718261719e-01
+	.quad	0x3FE19EE6B467C96F		# 5.50647079944610595703e-01
+	.quad	0x3FE1E85F5E7040D0		# 5.59615731239318847656e-01
+	.quad	0x3FE23130D7BEBF43		# 5.68504691123962402344e-01
+	.quad	0x3FE2795E1289B11B		# 5.77315330505371093750e-01
+	.quad	0x3FE2C0E9ED448E8C		# 5.86049020290374755859e-01
+	.quad	0x3FE307D7334F10BE		# 5.94707071781158447266e-01
+	.quad	0x3FE34E289D9CE1D3		# 6.03290796279907226562e-01
+	.quad	0x3FE393E0D3562A1A		# 6.11801505088806152344e-01
+	.quad	0x3FE3D9026A7156FB		# 6.20240390300750732422e-01
+	.quad	0x3FE41D8FE84672AE		# 6.28608644008636474609e-01
+	.quad	0x3FE4618BC21C5EC2		# 6.36907458305358886719e-01
+	.quad	0x3FE4A4F85DB03EBB		# 6.45137906074523925781e-01
+	.quad	0x3FE4E7D811B75BB1		# 6.53301239013671875000e-01
+	.quad	0x3FE52A2D265BC5AB		# 6.61398470401763916016e-01
+	.quad	0x3FE56BF9D5B3F399		# 6.69430613517761230469e-01
+	.quad	0x3FE5AD404C359F2D		# 6.77398800849914550781e-01
+	.quad	0x3FE5EE02A9241675		# 6.85303986072540283203e-01
+	.quad	0x3FE62E42FEFA39EF		# 6.93147122859954833984e-01
+	.quad 0					# for alignment
+
+.L__np_ln_lead_table:
+    .long 0x00000000  # 0.000000000000 0
+    .long 0x3C7E0000  # 0.015502929688 1
+    .long 0x3CFC1000  # 0.030769348145 2
+    .long 0x3D3BA000  # 0.045806884766 3
+    .long 0x3D785000  # 0.060623168945 4
+    .long 0x3D9A0000  # 0.075195312500 5
+    .long 0x3DB78000  # 0.089599609375 6
+    .long 0x3DD49000  # 0.103790283203 7
+    .long 0x3DF13000  # 0.117767333984 8
+    .long 0x3E06B000  # 0.131530761719 9
+    .long 0x3E14A000  # 0.145141601563 10
+    .long 0x3E226000  # 0.158569335938 11
+    .long 0x3E2FF000  # 0.171813964844 12
+    .long 0x3E3D5000  # 0.184875488281 13
+    .long 0x3E4A9000  # 0.197814941406 14
+    .long 0x3E579000  # 0.210510253906 15
+    .long 0x3E647000  # 0.223083496094 16
+    .long 0x3E713000  # 0.235534667969 17
+    .long 0x3E7DC000  # 0.247802734375 18
+    .long 0x3E851000  # 0.259887695313 19
+    .long 0x3E8B3000  # 0.271850585938 20
+    .long 0x3E914000  # 0.283691406250 21
+    .long 0x3E974000  # 0.295410156250 22
+    .long 0x3E9D3000  # 0.307006835938 23
+    .long 0x3EA30000  # 0.318359375000 24
+    .long 0x3EA8D000  # 0.329711914063 25
+    .long 0x3EAE8000  # 0.340820312500 26
+    .long 0x3EB43000  # 0.351928710938 27
+    .long 0x3EB9C000  # 0.362792968750 28
+    .long 0x3EBF5000  # 0.373657226563 29
+    .long 0x3EC4D000  # 0.384399414063 30
+    .long 0x3ECA3000  # 0.394897460938 31
+    .long 0x3ECF9000  # 0.405395507813 32
+    .long 0x3ED4E000  # 0.415771484375 33
+    .long 0x3EDA2000  # 0.426025390625 34
+    .long 0x3EDF5000  # 0.436157226563 35
+    .long 0x3EE47000  # 0.446166992188 36
+    .long 0x3EE99000  # 0.456176757813 37
+    .long 0x3EEEA000  # 0.466064453125 38
+    .long 0x3EF3A000  # 0.475830078125 39
+    .long 0x3EF89000  # 0.485473632813 40
+    .long 0x3EFD7000  # 0.494995117188 41
+    .long 0x3F012000  # 0.504394531250 42
+    .long 0x3F039000  # 0.513916015625 43
+    .long 0x3F05F000  # 0.523193359375 44
+    .long 0x3F084000  # 0.532226562500 45
+    .long 0x3F0AA000  # 0.541503906250 46
+    .long 0x3F0CF000  # 0.550537109375 47
+    .long 0x3F0F4000  # 0.559570312500 48
+    .long 0x3F118000  # 0.568359375000 49
+    .long 0x3F13C000  # 0.577148437500 50
+    .long 0x3F160000  # 0.585937500000 51
+    .long 0x3F183000  # 0.594482421875 52
+    .long 0x3F1A7000  # 0.603271484375 53
+    .long 0x3F1C9000  # 0.611572265625 54
+    .long 0x3F1EC000  # 0.620117187500 55
+    .long 0x3F20E000  # 0.628417968750 56
+    .long 0x3F230000  # 0.636718750000 57
+    .long 0x3F252000  # 0.645019531250 58
+    .long 0x3F273000  # 0.653076171875 59
+    .long 0x3F295000  # 0.661376953125 60
+    .long 0x3F2B5000  # 0.669189453125 61
+    .long 0x3F2D6000  # 0.677246093750 62
+    .long 0x3F2F7000  # 0.685302734375 63
+    .long 0x3F317000  # 0.693115234375 64
+    .long 0					# for alignment
+
+.L__np_ln_tail_table:
+    .long 0x00000000  # 0.000000000000 0
+    .long 0x35A8B0FC  # 0.000001256848 1
+    .long 0x361B0E78  # 0.000002310522 2
+    .long 0x3631EC66  # 0.000002651266 3
+    .long 0x35C30046  # 0.000001452871 4
+    .long 0x37EBCB0E  # 0.000028108738 5
+    .long 0x37528AE5  # 0.000012549314 6
+    .long 0x36DA7496  # 0.000006510479 7
+    .long 0x3783B715  # 0.000015701671 8
+    .long 0x383F3E68  # 0.000045596069 9
+    .long 0x38297C10  # 0.000040408282 10
+    .long 0x3815B666  # 0.000035694240 11
+    .long 0x38183854  # 0.000036292084 12
+    .long 0x38448108  # 0.000046850211 13
+    .long 0x373539E9  # 0.000010801924 14
+    .long 0x3864A740  # 0.000054515200 15
+    .long 0x387BE3CD  # 0.000060055219 16
+    .long 0x3803B715  # 0.000031403342 17
+    .long 0x380C36AF  # 0.000033429529 18
+    .long 0x3892713A  # 0.000069829126 19
+    .long 0x38AE55D6  # 0.000083129547 20
+    .long 0x38A0FDE8  # 0.000076766883 21
+    .long 0x3862BAE1  # 0.000054056643 22
+    .long 0x3798AAD3  # 0.000018199358 23
+    .long 0x38C5E10E  # 0.000094356117 24
+    .long 0x382D872E  # 0.000041372310 25
+    .long 0x38DEDFAC  # 0.000106274470 26
+    .long 0x38481E9B  # 0.000047712219 27
+    .long 0x38EBFB5E  # 0.000112524940 28
+    .long 0x38783B83  # 0.000059183232 29
+    .long 0x374E1B05  # 0.000012284848 30
+    .long 0x38CA0E11  # 0.000096347307 31
+    .long 0x3891F660  # 0.000069600297 32
+    .long 0x386C9A9A  # 0.000056410769 33
+    .long 0x38777BCD  # 0.000059004688 34
+    .long 0x38A6CED4  # 0.000079540216 35
+    .long 0x38FBE3CD  # 0.000120110439 36
+    .long 0x387E7E01  # 0.000060675669 37
+    .long 0x37D40984  # 0.000025276800 38
+    .long 0x3784C3AD  # 0.000015826745 39
+    .long 0x380F5FAF  # 0.000034182969 40
+    .long 0x38AC47BC  # 0.000082149607 41
+    .long 0x392952D3  # 0.000161479504 42
+    .long 0x37F97073  # 0.000029735476 43
+    .long 0x3865C84A  # 0.000054784388 44
+    .long 0x3979CF17  # 0.000238236375 45
+    .long 0x38C3D2F5  # 0.000093376184 46
+    .long 0x38E6B468  # 0.000110008579 47
+    .long 0x383EBCE1  # 0.000045475437 48
+    .long 0x39186BDF  # 0.000145360347 49
+    .long 0x392F0945  # 0.000166927537 50
+    .long 0x38E9ED45  # 0.000111545007 51
+    .long 0x396B99A8  # 0.000224685878 52
+    .long 0x37A27674  # 0.000019367064 53
+    .long 0x397069AB  # 0.000229275480 54
+    .long 0x39013539  # 0.000123222257 55
+    .long 0x3947F423  # 0.000190690669 56
+    .long 0x3945E10E  # 0.000188712234 57
+    .long 0x38F85DB0  # 0.000118430122 58
+    .long 0x396C08DC  # 0.000225100142 59
+    .long 0x37B4996F  # 0.000021529120 60
+    .long 0x397CEADA  # 0.000241200818 61
+    .long 0x3920261B  # 0.000152729845 62
+    .long 0x35AA4906  # 0.000001268724 63
+    .long 0x3805FDF4  # 0.000031946183 64
+    .long 0					# for alignment
+
diff --git a/src/gas/vrs4powf.S b/src/gas/vrs4powf.S
new file mode 100644
index 0000000..42b005d
--- /dev/null
+++ b/src/gas/vrs4powf.S
@@ -0,0 +1,623 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrs4powf.s
+#
+# A vector implementation of the powf libm function.
+#
+# Prototype:
+#
+#     __m128 __vrs4_powf(__m128 x,__m128 y);
+#
+#   Computes x raised to the y power.  Returns proper C99 values.
+#   Uses new tuned fastlog/fastexp.
+#
+#
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+
+# define local variable storage offsets
+.equ	p_temp,0x00		# xmmword
+.equ	p_negateres,0x10		# qword
+
+.equ	p_xexp,0x20		# qword
+
+.equ	p_ux,0x030		# storage for X
+.equ	p_uy,0x040		# storage for Y
+
+.equ	p_ax,0x050		# absolute x
+.equ	p_sx,0x060		# sign of x's
+
+.equ	p_ay,0x070		# absolute y
+.equ	p_yexp,0x080		# unbiased exponent of y
+
+.equ	p_inty,0x090		# integer y indicators
+.equ    save_rbx,0x0A0          #
+
+.equ	stack_size,0x0B8	# allocate 40h more than
+				# we need to avoid bank conflicts
+
+
+
+    .text
+    .align 16
+    .p2align 4,,15
+.globl __vrs4_powf
+    .type   __vrs4_powf,@function
+__vrs4_powf:
+	sub		$stack_size,%rsp
+        mov             %rbx,save_rbx(%rsp)     # save rbx
+
+	movaps	  %xmm0,p_ux(%rsp)		# save x
+	movaps	  %xmm1,p_uy(%rsp)		# save y
+
+	movaps	%xmm0,%xmm2
+	andps	.L__mask_nsign(%rip),%xmm0		# get abs x
+	andps	.L__mask_sign(%rip),%xmm2		# mask for the sign bits
+	movaps	  %xmm0,p_ax(%rsp)		# save them
+	movaps	  %xmm2,p_sx(%rsp)		# save them
+# convert all four x's to double
+	cvtps2pd   p_ax(%rsp),%xmm0
+	cvtps2pd   p_ax+8(%rsp),%xmm1
+#
+# classify y
+# vector 32 bit integer method	 25 cycles to here
+#  /* See whether y is an integer.
+#     inty = 0 means not an integer.
+#     inty = 1 means odd integer.
+#     inty = 2 means even integer.
+#  */
+	movdqa  p_uy(%rsp),%xmm4
+	pxor	%xmm3,%xmm3
+	pand	.L__mask_nsign(%rip),%xmm4		# get abs y in integer format
+	movdqa    %xmm4,p_ay(%rsp)			# save it
+
+# see if the number is less than 1.0
+	psrld	$23,%xmm4			#>> EXPSHIFTBITS_SP32
+
+	psubd	.L__mask_127(%rip),%xmm4			# yexp, unbiased exponent
+	movdqa    %xmm4,p_yexp(%rsp)		# save it
+	paddd	.L__mask_1(%rip),%xmm4			# yexp+1
+	pcmpgtd	%xmm3,%xmm4		# 0 if exp less than 126 (2^0) (y < 1.0), else FFs
+# xmm4 is ffs if abs(y) >=1.0, else 0
+
+# see if the mantissa has fractional bits
+#build mask for mantissa
+	movdqa  .L__mask_23(%rip),%xmm2
+	psubd	p_yexp(%rsp),%xmm2		# 24-yexp
+	pmaxsw	%xmm3,%xmm2							# no shift counts less than 0
+	movdqa    %xmm2,p_temp(%rsp)		# save the shift counts
+# create mask for all four values
+# SSE can't individual shifts so have to do 0xeac one seperately
+	mov		p_temp(%rsp),%rcx
+	mov		$1,%rbx
+	shl		%cl,%ebx			#1 << (24 - yexp)
+	shr		$32,%rcx
+	mov		$1,%eax
+	shl		%cl,%eax			#1 << (24 - yexp)
+	shl		$32,%rax
+	add		%rax,%rbx
+	mov		%rbx,p_temp(%rsp)
+	mov		p_temp+8(%rsp),%rcx
+	mov		$1,%rbx
+	shl		%cl,%ebx			#1 << (24 - yexp)
+	shr		$32,%rcx
+	mov		$1,%eax
+	shl		%cl,%eax			#1 << (24 - yexp)
+	shl		$32,%rax
+	add		%rbx,%rax
+	mov		%rax,p_temp+8(%rsp)
+	movdqa  p_temp(%rsp),%xmm5
+	psubd	.L__mask_1(%rip),%xmm5	#= mask = (1 << (24 - yexp)) - 1
+
+# now use the mask to see if there are any fractional bits
+	movdqa  p_uy(%rsp),%xmm2 # get uy
+	pand	%xmm5,%xmm2		# uy & mask
+	pcmpeqd	%xmm3,%xmm2		# 0 if not zero (y has fractional mantissa bits), else FFs
+	pand	%xmm4,%xmm2		# either 0s or ff
+# xmm2 now accounts for y< 1.0 or y>=1.0 and y has fractional mantissa bits,
+# it has the value 0 if we know it's non-integer or ff if integer.
+
+# now see if it's even or odd.
+
+## if yexp > 24, then it has to be even
+	movdqa  .L__mask_24(%rip),%xmm4
+	psubd	p_yexp(%rsp),%xmm4		# 24-yexp
+	paddd	.L__mask_1(%rip),%xmm5	# mask+1 = least significant integer bit
+	pcmpgtd	%xmm3,%xmm4		 ## if 0, then must be even, else ff's
+
+ 	pand	%xmm4,%xmm5		# set the integer bit mask to zero if yexp>24
+ 	paddd	.L__mask_2(%rip),%xmm4
+ 	por		.L__mask_2(%rip),%xmm4
+ 	pand	%xmm2,%xmm4		 # result can be 0, 2, or 3
+
+# now for integer numbers, see if odd or even
+	pand	.L__mask_mant(%rip),%xmm5	# mask out exponent bits
+	movdqa	.L__float_one(%rip),%xmm2
+	pand    p_uy(%rsp),%xmm5 #  & uy -> even or odd
+	pcmpeqd	p_ay(%rsp),%xmm2	# is ay equal to 1, ff's if so, then it's odd
+	pand	.L__mask_nsign(%rip),%xmm2 # strip the sign bit so the gt comparison works.
+	por		%xmm2,%xmm5
+	pcmpgtd	%xmm3,%xmm5		 ## if odd then ff's, else 0's for even
+	paddd	.L__mask_2(%rip),%xmm5 # gives us 2 for even, 1 for odd
+	pand	%xmm5,%xmm4
+
+	movdqa		  %xmm4,p_inty(%rsp)		# save inty
+#
+# do more x special case checking
+#
+	movdqa	%xmm4,%xmm5
+	pcmpeqd	%xmm3,%xmm5						# is not an integer? ff's if so
+	pand	.L__mask_NaN(%rip),%xmm5		# these values will be NaNs, if x<0
+	movdqa	%xmm4,%xmm2
+	pcmpeqd	.L__mask_1(%rip),%xmm2		# is it odd? ff's if so
+	pand	.L__mask_sign(%rip),%xmm2	# these values will get their sign bit set
+	por		%xmm2,%xmm5
+
+	pcmpeqd	p_sx(%rsp),%xmm3		## if the signs are set
+	pandn	%xmm5,%xmm3						# then negateres gets the values as shown below
+	movdqa	  %xmm3,p_negateres(%rsp)	# save negateres
+
+#  /* p_negateres now means the following.
+#  ** 7FC00000 means x<0, y not an integer, return NaN.
+#  ** 80000000 means x<0, y is odd integer, so set the sign bit.
+#  ** 0 means even integer, and/or x>=0.
+#  */
+
+
+# **** Here starts the main calculations  ****
+# The algorithm used is x**y = exp(y*log(x))
+#  Extra precision is required in intermediate steps to meet the 1ulp requirement
+#
+# log(x) calculation
+	call		__vrd4_log@PLT					# get the double precision log value
+											# for all four x's
+# y* logx
+# convert all four y's to double
+	lea	p_uy(%rsp),%rdx		# get pointer to y
+	cvtps2pd   (%rdx),%xmm2
+	cvtps2pd   8(%rdx),%xmm3
+
+#  /* just multiply by y */
+	mulpd	%xmm2,%xmm0
+	mulpd	%xmm3,%xmm1
+
+#  /* The following code computes r = exp(w) */
+	call		__vrd4_exp@PLT					# get the double exp value
+											# for all four y*log(x)'s
+#
+# convert all four results to double
+	cvtpd2ps	%xmm0,%xmm0
+	cvtpd2ps	%xmm1,%xmm1
+	movlhps		%xmm1,%xmm0
+
+# perform special case and error checking on input values
+
+# special case checking is done first in the scalar version since
+# it allows for early fast returns.  But for vectors, we consider them
+# to be rare, so early returns are not necessary.  So we first compute
+# the x**y values, and then check for special cases.
+
+# we do some of the checking in reverse order of the scalar version.
+	lea	p_uy(%rsp),%rdx		# get pointer to y
+# apply the negate result flags
+	orps	p_negateres(%rsp),%xmm0	# get negateres
+
+## if y is infinite or so large that the result would overflow or underflow
+	movdqa	p_ay(%rsp),%xmm4
+	cmpps	$5,.L__mask_ly(%rip),%xmm4	# y not less than large value, ffs if so.
+	movmskps %xmm4,%edx
+	test	$0x0f,%edx
+	jnz		.Ly_large
+.Lrnsx3:
+
+## if x is infinite
+	movdqa	p_ax(%rsp),%xmm4
+	cmpps	$0,.L__mask_inf(%rip),%xmm4	# equal to infinity, ffs if so.
+	movmskps %xmm4,%edx
+	test	$0x0f,%edx
+	jnz		.Lx_infinite
+.Lrnsx1:
+## if x is zero
+	xorps	%xmm4,%xmm4
+	cmpps	$0,p_ax(%rsp),%xmm4	# equal to zero, ffs if so.
+	movmskps %xmm4,%edx
+	test	$0x0f,%edx
+	jnz		.Lx_zero
+.Lrnsx2:
+## if y is NAN
+	lea		p_uy(%rsp),%rdx		# get pointer to y
+	movdqa	(%rdx),%xmm4			# get y
+	cmpps	$4,%xmm4,%xmm4						# a compare not equal  of y to itself should
+											# be false, unless y is a NaN. ff's if NaN.
+	movmskps %xmm4,%ecx
+	test	$0x0f,%ecx
+	jnz		.Ly_NaN
+.Lrnsx4:
+## if x is NAN
+	lea		p_ux(%rsp),%rdx		# get pointer to x
+	movdqa	(%rdx),%xmm4			# get x
+	cmpps	$4,%xmm4,%xmm4						# a compare not equal  of x to itself should
+											# be false, unless x is a NaN. ff's if NaN.
+	movmskps %xmm4,%ecx
+	test	$0x0f,%ecx
+	jnz		.Lx_NaN
+.Lrnsx5:
+
+## if |y| == 0	then return 1
+	movdqa	.L__float_one(%rip),%xmm3	# one
+	xorps	%xmm2,%xmm2
+	cmpps	$4,p_ay(%rsp),%xmm2	# not equal to 0.0?, ffs if not equal.
+	andps	%xmm2,%xmm0						# keep the others
+	andnps	%xmm3,%xmm2						# mask for ones
+	orps	%xmm2,%xmm0
+## if x == +1, return +1 for all x
+	lea		p_ux(%rsp),%rdx		# get pointer to x
+	movdqa	%xmm3,%xmm2
+	cmpps	$4,(%rdx),%xmm2		# not equal to +1.0?, ffs if not equal.
+	andps	%xmm2,%xmm0						# keep the others
+	andnps	%xmm3,%xmm2						# mask for ones
+	orps	%xmm2,%xmm0
+
+.L__powf_cleanup2:
+        mov             save_rbx(%rsp),%rbx             # restore rbx
+	add		$stack_size,%rsp
+	ret
+
+	.align 16
+#       y is a NaN.
+.Ly_NaN:
+	lea	p_uy(%rsp),%rdx		# get pointer to y
+	movdqa	(%rdx),%xmm4			# get y
+	movdqa	%xmm4,%xmm3
+	movdqa	%xmm4,%xmm5
+	movdqa	.L__mask_sigbit(%rip),%xmm2	# get the signalling bits
+	cmpps	$0,%xmm4,%xmm4						# a compare equal  of y to itself should
+											# be true, unless y is a NaN. 0's if NaN.
+	cmpps	$4,%xmm3,%xmm3						# compare not equal, ff's if NaN.
+	andps	%xmm4,%xmm0						# keep the other results
+	andps	%xmm3,%xmm2						# get just the right signalling bits
+	andps	%xmm5,%xmm3						# mask for the NaNs
+	orps	%xmm2,%xmm3	# convert to QNaNs
+	orps	%xmm3,%xmm0						# combine
+	jmp	   	.Lrnsx4
+
+#       y is a NaN.
+.Lx_NaN:
+	lea		p_ux(%rsp),%rcx		# get pointer to x
+	movdqa	(%rcx),%xmm4			# get x
+	movdqa	%xmm4,%xmm3
+	movdqa	%xmm4,%xmm5
+	movdqa	.L__mask_sigbit(%rip),%xmm2	# get the signalling bits
+	cmpps	$0,%xmm4,%xmm4						# a compare equal  of x to itself should
+											# be true, unless x is a NaN. 0's if NaN.
+	cmpps	$4,%xmm3,%xmm3						# compare not equal, ff's if NaN.
+	andps	%xmm4,%xmm0						# keep the other results
+	andps	%xmm3,%xmm2						# get just the right signalling bits
+	andps	%xmm5,%xmm3						# mask for the NaNs
+	orps	%xmm2,%xmm3	# convert to QNaNs
+	orps	%xmm3,%xmm0						# combine
+	jmp	   	.Lrnsx5
+
+#      * y is infinite or so large that the result would
+#         overflow or underflow.
+.Ly_large:
+	movdqa	  %xmm0,p_temp(%rsp)
+
+	test	$1,%edx
+	jz		.Lylrga
+	lea		p_ux(%rsp),%rcx		# get pointer to x
+	lea		p_uy(%rsp),%rbx		# get pointer to y
+	mov		(%rcx),%eax
+	mov		(%rbx),%ebx
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special6					# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp(%rsp)
+.Lylrga:
+	test	$2,%edx
+	jz		.Lylrgb
+	lea		p_ux(%rsp),%rcx		# get pointer to x
+	lea		p_uy(%rsp),%rbx		# get pointer to y
+	mov		4(%rcx),%eax
+	mov		4(%rbx),%ebx
+	mov		p_inty+4(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special6					# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+4(%rsp)
+.Lylrgb:
+	test	$4,%edx
+	jz		.Lylrgc
+	lea		p_ux(%rsp),%rcx		# get pointer to x
+	lea		p_uy(%rsp),%rbx		# get pointer to y
+	mov		8(%rcx),%eax
+	mov		8(%rbx),%ebx
+	mov		p_inty+8(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special6					# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+8(%rsp)
+.Lylrgc:
+	test	$8,%edx
+	jz		.Lylrgd
+	lea		p_ux(%rsp),%rcx		# get pointer to x
+	lea		p_uy(%rsp),%rbx		# get pointer to y
+	mov		12(%rcx),%eax
+	mov		12(%rbx),%ebx
+	mov		p_inty+12(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special6					# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+12(%rsp)
+.Lylrgd:
+	movdqa	p_temp(%rsp),%xmm0
+	jmp 	.Lrnsx3
+
+# a subroutine to treat an individual x,y pair when y is large or infinity
+# assumes x in .Ly,%eax in ebx.
+# returns result in eax
+.Lnp_special6:
+# handle |x|==1 cases first
+	mov		$0x07FFFFFFF,%r8d
+	and		%eax,%r8d
+	cmp		$0x03f800000,%r8d					  # jump if |x| !=1
+	jnz		.Lnps6
+	mov		$0x03f800000,%eax					  # return 1 for all |x|==1
+	jmp 	.Lnpx64
+
+# cases where  |x| !=1
+.Lnps6:
+	mov		$0x07f800000,%ecx
+	xor		%eax,%eax							  # assume 0 return
+	test	$0x080000000,%ebx
+	jnz		.Lnps62							  # jump if y negative
+# y = +inf
+	cmp		$0x03f800000,%r8d
+	cmovg	%ecx,%eax							  # return inf if |x| < 1
+	jmp 	.Lnpx64
+.Lnps62:
+# y = -inf
+	cmp		$0x03f800000,%r8d
+	cmovl	%ecx,%eax							  # return inf if |x| < 1
+	jmp 	.Lnpx64
+
+.Lnpx64:
+	ret
+
+# handle cases where x is +/- infinity.  edx is the mask
+	.align 16
+.Lx_infinite:
+	movdqa	  %xmm0,p_temp(%rsp)
+
+	test	$1,%edx
+	jz		.Lxinfa
+	lea		p_ux(%rsp),%rcx		# get pointer to x
+	lea		p_uy(%rsp),%rbx		# get pointer to y
+	mov		(%rcx),%eax
+	mov		(%rbx),%ebx
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x1					# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp(%rsp)
+.Lxinfa:
+	test	$2,%edx
+	jz		.Lxinfb
+	lea		p_ux(%rsp),%rcx		# get pointer to x
+	lea		p_uy(%rsp),%rbx		# get pointer to y
+	mov		4(%rcx),%eax
+	mov		4(%rbx),%ebx
+	mov		p_inty+4(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x1					# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+4(%rsp)
+.Lxinfb:
+	test	$4,%edx
+	jz		.Lxinfc
+	lea		p_ux(%rsp),%rcx		# get pointer to x
+	lea		p_uy(%rsp),%rbx		# get pointer to y
+	mov		8(%rcx),%eax
+	mov		8(%rbx),%ebx
+	mov		p_inty+8(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x1					# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+8(%rsp)
+.Lxinfc:
+	test	$8,%edx
+	jz		.Lxinfd
+	lea		p_ux(%rsp),%rcx		# get pointer to x
+	lea		p_uy(%rsp),%rbx		# get pointer to y
+	mov		12(%rcx),%eax
+	mov		12(%rbx),%ebx
+	mov		p_inty+12(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x1					# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+12(%rsp)
+.Lxinfd:
+	movdqa	p_temp(%rsp),%xmm0
+	jmp 	.Lrnsx1
+
+# a subroutine to treat an individual x,y pair when x is +/-infinity
+# assumes x in .Ly,%eax in ebx, inty in ecx.
+# returns result in eax
+.Lnp_special_x1:											# x is infinite
+	test	$0x080000000,%eax								# is x positive
+	jnz		.Lnsx11										# jump if not
+	test	$0x080000000,%ebx								# is y positive
+	jz		.Lnsx13											# just return if so
+	xor		%eax,%eax										# else return 0
+	jmp 	.Lnsx13
+
+.Lnsx11:
+	cmp		$1,%ecx										## if inty ==1
+	jnz		.Lnsx12										# jump if not
+	test	$0x080000000,%ebx								# is y positive
+	jz		.Lnsx13											# just return if so
+	mov		$0x080000000,%eax								# else return -0
+	jmp 	.Lnsx13
+.Lnsx12:													# inty <>1
+	and		$0x07FFFFFFF,%eax								# return -x (|x|)  if y<0
+	test	$0x080000000,%ebx								# is y positive
+	jz		.Lnsx13											#
+	xor		%eax,%eax										# return 0  if y >=0
+.Lnsx13:
+	ret
+
+
+# handle cases where x is +/- zero.  edx is the mask of x,y pairs with |x|=0
+	.align 16
+.Lx_zero:
+	movdqa	  %xmm0,p_temp(%rsp)
+
+	test	$1,%edx
+	jz		.Lxzera
+	lea		p_ux(%rsp),%rcx		# get pointer to x
+	lea		p_uy(%rsp),%rbx		# get pointer to y
+	mov		(%rcx),%eax
+	mov		(%rbx),%ebx
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x2					# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp(%rsp)
+.Lxzera:
+	test	$2,%edx
+	jz		.Lxzerb
+	lea		p_ux(%rsp),%rcx		# get pointer to x
+	lea		p_uy(%rsp),%rbx		# get pointer to y
+	mov		4(%rcx),%eax
+	mov		4(%rbx),%ebx
+	mov		p_inty+4(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x2					# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+4(%rsp)
+.Lxzerb:
+	test	$4,%edx
+	jz		.Lxzerc
+	lea		p_ux(%rsp),%rcx		# get pointer to x
+	lea		p_uy(%rsp),%rbx		# get pointer to y
+	mov		8(%rcx),%eax
+	mov		8(%rbx),%ebx
+	mov		p_inty+8(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x2					# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+8(%rsp)
+.Lxzerc:
+	test	$8,%edx
+	jz		.Lxzerd
+	lea		p_ux(%rsp),%rcx		# get pointer to x
+	lea		p_uy(%rsp),%rbx		# get pointer to y
+	mov		12(%rcx),%eax
+	mov		12(%rbx),%ebx
+	mov		p_inty+12(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x2					# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+12(%rsp)
+.Lxzerd:
+	movdqa	p_temp(%rsp),%xmm0
+	jmp 	.Lrnsx2
+
+# a subroutine to treat an individual x,y pair when x is +/-0
+# assumes x in .Ly,%eax in ebx, inty in ecx.
+# returns result in eax
+	.align 16
+.Lnp_special_x2:
+	cmp		$1,%ecx										## if inty ==1
+	jz		.Lnsx21										# jump if so
+# handle cases of x=+/-0, y not integer
+	xor		%eax,%eax
+	mov		$0x07f800000,%ecx
+	test	$0x080000000,%ebx								# is ypos
+	cmovnz	%ecx,%eax
+	jmp		.Lnsx23
+# y is an integer
+.Lnsx21:
+	xor		%r8d,%r8d
+	mov		$0x07f800000,%ecx
+	test	$0x080000000,%ebx								# is ypos
+	cmovnz	%ecx,%r8d										# set to infinity if not
+	and		$0x080000000,%eax								# pickup the sign of x
+	or		%r8d,%eax										# and include it in the result
+.Lnsx23:
+	ret
+
+
+        .data
+        .align 64
+
+.L__mask_sign:			.quad 0x08000000080000000	# a sign bit mask
+				.quad 0x08000000080000000
+
+.L__mask_nsign:			.quad 0x07FFFFFFF7FFFFFFF	# a not sign bit mask
+				.quad 0x07FFFFFFF7FFFFFFF
+
+# used by inty
+.L__mask_127:			.quad 0x00000007F0000007F	# EXPBIAS_SP32
+				.quad 0x00000007F0000007F
+
+.L__mask_mant:			.quad 0x0007FFFFF007FFFFF	# mantissa bit mask
+				.quad 0x0007FFFFF007FFFFF
+
+.L__mask_1:			.quad 0x00000000100000001	# 1
+				.quad 0x00000000100000001
+
+.L__mask_2:			.quad 0x00000000200000002	# 2
+				.quad 0x00000000200000002
+
+.L__mask_24:			.quad 0x00000001800000018	# 24
+				.quad 0x00000001800000018
+
+.L__mask_23:			.quad 0x00000001700000017	# 23
+				.quad 0x00000001700000017
+
+# used by special case checking
+
+.L__float_one:			.quad 0x03f8000003f800000	# one
+				.quad 0x03f8000003f800000
+
+.L__mask_inf:			.quad 0x07f8000007F800000	# inifinity
+				.quad 0x07f8000007F800000
+
+.L__mask_NaN:			.quad 0x07fC000007FC00000	# NaN
+				.quad 0x07fC000007FC00000
+
+.L__mask_sigbit:		.quad 0x00040000000400000	# QNaN bit
+				.quad 0x00040000000400000
+
+.L__mask_ly:			.quad 0x04f0000004f000000	# large y
+				.quad 0x04f0000004f000000
diff --git a/src/gas/vrs4powxf.S b/src/gas/vrs4powxf.S
new file mode 100644
index 0000000..e18b5db
--- /dev/null
+++ b/src/gas/vrs4powxf.S
@@ -0,0 +1,538 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrs4powxf.asm
+#
+# A vector implementation of the powf libm function.
+# This routine raises the x vector to a constant y power.
+#
+# Prototype:
+#
+#     __m128 __vrs4_powxf(__m128 x,float y);
+#
+#   Computes x raised to the y power.  Returns proper C99 values.
+#
+#
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+
+
+# define local variable storage offsets
+.equ	p_temp,0x00		# xmmword
+.equ	p_negateres,0x10	# qword
+
+.equ	save_rbx,0x020		#qword
+.equ	save_rsi,0x028		#qword
+
+.equ	p_xptr,0x030		# ptr to x values
+.equ	p_y,0x038		# y value
+
+.equ	p_inty,0x040		# integer y indicators
+
+.equ	p_ux,0x050		# absolute x
+.equ	p_ax,0x060		# absolute x
+.equ	p_sx,0x070		# sign of x's
+
+.equ	stack_size,0x088	#
+
+
+
+
+
+    .text
+    .align 16
+    .p2align 4,,15
+.globl __vrs4_powxf
+    .type   __vrs4_powxf,@function
+__vrs4_powxf:
+
+	sub		$stack_size,%rsp
+	mov		%rbx,save_rbx(%rsp)	# save rbx
+
+	lea		p_ux(%rsp),%rcx
+	mov		  %rcx,p_xptr(%rsp)		# save pointer to x
+	movaps		%xmm0,(%rcx)
+	movss	  %xmm1,p_y(%rsp)		# save y
+
+	movdqa	%xmm1,%xmm4
+
+	movaps	%xmm0,%xmm2
+	andps	.L__mask_nsign(%rip),%xmm0		# get abs x
+	andps	.L__mask_sign(%rip),%xmm2			# mask for the sign bits
+	movaps	  %xmm0,p_ax(%rsp)		# save them
+	movaps	  %xmm2,p_sx(%rsp)		# save them
+# convert all four x's to double
+	cvtps2pd   p_ax(%rsp),%xmm0
+	cvtps2pd   p_ax+8(%rsp),%xmm1
+#
+# classify y
+# vector 32 bit integer method	 25 cycles to here
+#  /* See whether y is an integer.
+#     inty = 0 means not an integer.
+#  */
+# get yexp
+	mov		p_y(%rsp),%r8d						# r8 is uy
+	mov		$0x07fffffff,%r9d
+	and		%r8d,%r9d						# r9 is ay
+
+## if |y| == 0	then return 1
+	cmp		$0,%r9d							# is y a zero?
+	jz		.Ly_zero
+
+	mov		$0x07f800000,%eax				# EXPBITS_SP32
+	and		%r9d,%eax						# y exp
+
+	xor		%edi,%edi
+	shr		$23,%eax			#>> EXPSHIFTBITS_SP32
+	sub		$126,%eax		# - EXPBIAS_SP32 + 1   - eax is now the unbiased exponent
+	mov		$1,%ebx
+	cmp		%ebx,%eax			## if (yexp < 1)
+	cmovl	%edi,%ebx
+	jl		.Lsave_inty
+
+	mov		$24,%ecx
+	cmp		%ecx,%eax			## if (yexp >24)
+	jle		.Linfy1
+	mov		$2,%ebx
+	jmp		.Lsave_inty
+.Linfy1:						# else 1<=yexp<=24
+	sub		%eax,%ecx			# build mask for mantissa
+	shl		%cl,%ebx
+	dec		%ebx				# rbx = mask = (1 << (24 - yexp)) - 1
+
+	mov		%r8d,%eax
+	and		%ebx,%eax			## if ((uy & mask) != 0)
+	cmovnz	%edi,%ebx			#   inty = 0;
+	jnz		.Lsave_inty
+
+	not		%ebx				# else if (((uy & ~mask) >> (24 - yexp)) & 0x00000001)
+	mov		%r8d,%eax
+	and		%ebx,%eax
+	shr		%cl,%eax
+	inc		%edi
+	and		%edi,%eax
+	mov		%edi,%ebx			#  inty = 1
+	jnz		.Lsave_inty
+	inc		%ebx				# else	inty = 2
+
+
+.Lsave_inty:
+	mov		  %r8d,p_y+4(%rsp)						# r8d is ay
+	mov		  %ebx,p_inty(%rsp)		# save inty
+#
+# do more x special case checking
+#
+	pxor	%xmm3,%xmm3
+	xor		%eax,%eax
+	mov		$0x07FC00000,%ecx
+	cmp		$0,%ebx							# is y not an integer?
+	cmovz	%ecx,%eax							# then set to return a NaN.  else 0.
+	mov		$0x080000000,%ecx
+	cmp		$1,%ebx							# is y an odd integer?
+	cmovz	%ecx,%eax							# maybe set sign bit if so
+	movd	%eax,%xmm5
+	pshufd	$0,%xmm5,%xmm5
+
+	pcmpeqd	p_sx(%rsp),%xmm3		## if the signs are set
+	pandn	%xmm5,%xmm3						# then negateres gets the values as shown below
+	movdqa	  %xmm3,p_negateres(%rsp)	# save negateres
+
+#  /* p_negateres now means the following.
+#     7FC00000 means x<0, y not an integer, return NaN.
+#     80000000 means x<0, y is odd integer, so set the sign bit.
+##     0 means even integer, and/or x>=0.
+#  */
+
+# **** Here starts the main calculations  ****
+# The algorithm used is x**y = exp(y*log(x))
+#  Extra precision is required in intermediate steps to meet the 1ulp requirement
+#
+# log(x) calculation
+	call		__vrd4_log@PLT					# get the double precision log value
+											# for all four x's
+# y* logx
+	cvtps2pd   p_y(%rsp),%xmm2		#convert the two packed single y's to double
+
+#  /* just multiply by y */
+	mulpd	%xmm2,%xmm0
+	mulpd	%xmm2,%xmm1
+
+#  /* The following code computes r = exp(w) */
+	call		__vrd4_exp@PLT					# get the double exp value
+											# for all four y*log(x)'s
+#
+# convert all four results to double
+	cvtpd2ps	%xmm0,%xmm0
+	cvtpd2ps	%xmm1,%xmm1
+	movlhps		%xmm1,%xmm0
+
+# perform special case and error checking on input values
+
+# special case checking is done first in the scalar version since
+# it allows for early fast returns.  But for vectors, we consider them
+# to be rare, so early returns are not necessary.  So we first compute
+# the x**y values, and then check for special cases.
+
+# we do some of the checking in reverse order of the scalar version.
+# apply the negate result flags
+	orps	p_negateres(%rsp),%xmm0	# get negateres
+
+## if y is infinite or so large that the result would overflow or underflow
+	mov		p_y(%rsp),%edx			# get y
+	and 	$0x07fffffff,%edx					# develop ay
+	cmp		$0x04f000000,%edx
+	ja		.Ly_large
+.Lrnsx3:
+
+## if x is infinite
+	movdqa	p_ax(%rsp),%xmm4
+	cmpps	$0,.L__mask_inf(%rip),%xmm4	# equal to infinity, ffs if so.
+	movmskps %xmm4,%edx
+	test	$0x0f,%edx
+	jnz		.Lx_infinite
+.Lrnsx1:
+## if x is zero
+	xorps	%xmm4,%xmm4
+	cmpps	$0,p_ax(%rsp),%xmm4	# equal to zero, ffs if so.
+	movmskps %xmm4,%edx
+	test	$0x0f,%edx
+	jnz		.Lx_zero
+.Lrnsx2:
+## if y is NAN
+	movss	p_y(%rsp),%xmm4			# get y
+	ucomiss	%xmm4,%xmm4						# comparing y to itself should
+											# be true, unless y is a NaN. parity flag if NaN.
+	jp		.Ly_NaN
+.Lrnsx4:
+## if x is NAN
+	movdqa	p_ax(%rsp),%xmm4			# get x
+	cmpps	$4,%xmm4,%xmm4						# a compare not equal  of x to itself should
+											# be false, unless x is a NaN. ff's if NaN.
+	movmskps %xmm4,%ecx
+	test	$0x0f,%ecx
+	jnz		.Lx_NaN
+.Lrnsx5:
+
+## if x == +1, return +1 for all x
+	movdqa	.L__float_one(%rip),%xmm3	# one
+	mov		p_xptr(%rsp),%rdx		# get pointer to x
+	movdqa	%xmm3,%xmm2
+	cmpps	$4,(%rdx),%xmm2		# not equal to +1.0?, ffs if not equal.
+	andps	%xmm2,%xmm0						# keep the others
+	andnps	%xmm3,%xmm2						# mask for ones
+	orps	%xmm2,%xmm0
+
+.L__powf_cleanup2:
+
+	mov		save_rbx(%rsp),%rbx		# restore rbx
+	add		$stack_size,%rsp
+	ret
+
+	.align 16
+.Ly_zero:
+## if |y| == 0	then return 1
+	movdqa	.L__float_one(%rip),%xmm0	# one
+	jmp		.L__powf_cleanup2
+#      * y is a NaN.
+.Ly_NaN:
+	mov		p_y(%rsp),%r8d
+	or		$0x000400000,%r8d				# convert to QNaNs
+	movd	%r8d,%xmm0					# propagate to all results
+	shufps	$0,%xmm0,%xmm0
+	jmp	   	.Lrnsx4
+
+#       y is a NaN.
+.Lx_NaN:
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	movdqa	(%rcx),%xmm4			# get x
+	movdqa	%xmm4,%xmm3
+	movdqa	%xmm4,%xmm5
+	movdqa	.L__mask_sigbit(%rip),%xmm2	# get the signalling bits
+	cmpps	$0,%xmm4,%xmm4						# a compare equal  of x to itself should
+											# be true, unless x is a NaN. 0's if NaN.
+	cmpps	$4,%xmm3,%xmm3						# compare not equal, ff's if NaN.
+	andps	%xmm4,%xmm0						# keep the other results
+	andps	%xmm3,%xmm2						# get just the right signalling bits
+	andps	%xmm5,%xmm3						# mask for the NaNs
+	orps	%xmm2,%xmm3	# convert to QNaNs
+	orps	%xmm3,%xmm0						# combine
+	jmp	   	.Lrnsx5
+
+#      * y is infinite or so large that the result would
+#         overflow or underflow.
+.Ly_large:
+	movdqa	  %xmm0,p_temp(%rsp)
+
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		(%rcx),%eax
+	mov		p_y(%rsp),%ebx
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special6					# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp(%rsp)
+
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		4(%rcx),%eax
+	mov		p_y(%rsp),%ebx
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special6					# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+4(%rsp)
+
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		8(%rcx),%eax
+	mov		p_y(%rsp),%ebx
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special6					# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+8(%rsp)
+
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		12(%rcx),%eax
+	mov		p_y(%rsp),%ebx
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special6					# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+12(%rsp)
+
+	movdqa	p_temp(%rsp),%xmm0
+	jmp 	.Lrnsx3
+
+# a subroutine to treat an individual x,y pair when y is large or infinity
+# assumes x in .Ly(%rip),%eax in ebx.
+# returns result in eax
+.Lnp_special6:
+# handle |x|==1 cases first
+	mov		$0x07FFFFFFF,%r8d
+	and		%eax,%r8d
+	cmp		$0x03f800000,%r8d					  # jump if |x| !=1
+	jnz		.Lnps6
+	mov		$0x03f800000,%eax					  # return 1 for all |x|==1
+	jmp 	.Lnpx64
+
+# cases where  |x| !=1
+.Lnps6:
+	mov		$0x07f800000,%ecx
+	xor		%eax,%eax							  # assume 0 return
+	test	$0x080000000,%ebx
+	jnz		.Lnps62							  # jump if y negative
+# y = +inf
+	cmp		$0x03f800000,%r8d
+	cmovg	%ecx,%eax							  # return inf if |x| < 1
+	jmp 	.Lnpx64
+.Lnps62:
+# y = -inf
+	cmp		$0x03f800000,%r8d
+	cmovl	%ecx,%eax							  # return inf if |x| < 1
+	jmp 	.Lnpx64
+
+.Lnpx64:
+	ret
+
+# handle cases where x is +/- infinity.  edx is the mask
+	.align 16
+.Lx_infinite:
+	movdqa	  %xmm0,p_temp(%rsp)
+
+	test	$1,%edx
+	jz		.Lxinfa
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		(%rcx),%eax
+	mov		p_y(%rsp),%ebx
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x1					# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp(%rsp)
+.Lxinfa:
+	test	$2,%edx
+	jz		.Lxinfb
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		p_y(%rsp),%ebx
+	mov		4(%rcx),%eax
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x1					# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+4(%rsp)
+.Lxinfb:
+	test	$4,%edx
+	jz		.Lxinfc
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		p_y(%rsp),%ebx
+	mov		8(%rcx),%eax
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x1					# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+8(%rsp)
+.Lxinfc:
+	test	$8,%edx
+	jz		.Lxinfd
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		p_y(%rsp),%ebx
+	mov		12(%rcx),%eax
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x1					# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+12(%rsp)
+.Lxinfd:
+	movdqa	p_temp(%rsp),%xmm0
+	jmp 	.Lrnsx1
+
+# a subroutine to treat an individual x,y pair when x is +/-infinity
+# assumes x in .Ly(%rip),%eax in ebx, inty in ecx.
+# returns result in eax
+.Lnp_special_x1:											# x is infinite
+	test	$0x080000000,%eax								# is x positive
+	jnz		.Lnsx11										# jump if not
+	test	$0x080000000,%ebx								# is y positive
+	jz		.Lnsx13											# just return if so
+	xor		%eax,%eax										# else return 0
+	jmp 	.Lnsx13
+
+.Lnsx11:
+	cmp		$1,%ecx										## if inty ==1
+	jnz		.Lnsx12										# jump if not
+	test	$0x080000000,%ebx								# is y positive
+	jz		.Lnsx13											# just return if so
+	mov		$0x080000000,%eax								# else return -0
+	jmp 	.Lnsx13
+.Lnsx12:													# inty <>1
+	and		$0x07FFFFFFF,%eax								# return -x (|x|)  if y<0
+	test	$0x080000000,%ebx								# is y positive
+	jz		.Lnsx13											#
+	xor		%eax,%eax										# return 0  if y >=0
+.Lnsx13:
+	ret
+
+
+# handle cases where x is +/- zero.  edx is the mask of x,y pairs with |x|=0
+	.align 16
+.Lx_zero:
+	movdqa	  %xmm0,p_temp(%rsp)
+
+	test	$1,%edx
+	jz		.Lxzera
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		p_y(%rsp),%ebx
+	mov		(%rcx),%eax
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x2					# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp(%rsp)
+.Lxzera:
+	test	$2,%edx
+	jz		.Lxzerb
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		p_y(%rsp),%ebx
+	mov		4(%rcx),%eax
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x2					# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+4(%rsp)
+.Lxzerb:
+	test	$4,%edx
+	jz		.Lxzerc
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		p_y(%rsp),%ebx
+	mov		8(%rcx),%eax
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x2					# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+8(%rsp)
+.Lxzerc:
+	test	$8,%edx
+	jz		.Lxzerd
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		p_y(%rsp),%ebx
+	mov		12(%rcx),%eax
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x2					# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+12(%rsp)
+.Lxzerd:
+	movdqa	p_temp(%rsp),%xmm0
+	jmp 	.Lrnsx2
+
+# a subroutine to treat an individual x,y pair when x is +/-0
+# assumes x in .Ly(%rip),%eax in ebx, inty in ecx.
+# returns result in eax
+	.align 16
+.Lnp_special_x2:
+	cmp		$1,%ecx										## if inty ==1
+	jz		.Lnsx21										# jump if so
+# handle cases of x=+/-0, y not integer
+	xor		%eax,%eax
+	mov		$0x07f800000,%ecx
+	test	$0x080000000,%ebx								# is ypos
+	cmovnz	%ecx,%eax
+	jmp		.Lnsx23
+# y is an integer
+.Lnsx21:
+	xor		%r8d,%r8d
+	mov		$0x07f800000,%ecx
+	test	$0x080000000,%ebx								# is ypos
+	cmovnz	%ecx,%r8d										# set to infinity if not
+	and		$0x080000000,%eax								# pickup the sign of x
+	or		%r8d,%eax										# and include it in the result
+.Lnsx23:
+	ret
+
+
+        .data
+        .align 64
+
+.L__mask_sign:			.quad 0x08000000080000000	# a sign bit mask
+				.quad 0x08000000080000000
+
+.L__mask_nsign:			.quad 0x07FFFFFFF7FFFFFFF	# a not sign bit mask
+				.quad 0x07FFFFFFF7FFFFFFF
+
+# used by special case checking
+
+.L__float_one:			.quad 0x03f8000003f800000	# one
+				.quad 0x03f8000003f800000
+
+.L__mask_inf:			.quad 0x07f8000007F800000	# inifinity
+				.quad 0x07f8000007F800000
+
+.L__mask_sigbit:		.quad 0x00040000000400000	# QNaN bit
+				.quad 0x00040000000400000
+
+
diff --git a/src/gas/vrs4sincosf.S b/src/gas/vrs4sincosf.S
new file mode 100644
index 0000000..2c3a0cc
--- /dev/null
+++ b/src/gas/vrs4sincosf.S
@@ -0,0 +1,1813 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrs4sincosf.asm
+#
+# A vector implementation of the sincos libm function.
+#
+# Prototype:
+#
+#    __vrs4_sincosf(__m128 x, __m128 * ys, __m128 * yc);
+#
+# Computes Sine and Cosine of x for an array of input values.
+# Places the Sine results into the supplied ys array and the Cosine results into the supplied yc array.
+# Does not perform error checking.
+# Denormal inputs may produce unexpected results.
+# This routine computes 4 single precision Sine Cosine values at a time.
+# The four values are passed as packed single in xmm0.
+# The four Sine results are returned as packed singles in the supplied ys array.
+# The four Cosine results are returned as packed singles in the supplied yc array.
+# Note that this represents a non-standard ABI usage, as no ABI
+# ( and indeed C) currently allows returning 2 values for a function.
+# It is expected that some compilers may be able to take advantage of this
+# interface when implementing vectorized loops.  Using the array implementation
+# of the routine requires putting the inputs into memory, and retrieving
+# the results from memory.  This routine eliminates the need for this
+# overhead if the data does not already reside in memory.
+
+# Author: Harsha Jagasia
+# Email:  harsha.jagasia@amd.com
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.data
+.align 64
+.L__real_7fffffffffffffff: .quad 0x07fffffffffffffff	#Sign bit zero
+			.quad 0x07fffffffffffffff
+.L__real_3ff0000000000000: .quad 0x03ff0000000000000	# 1.0
+			.quad 0x03ff0000000000000
+.L__real_v2p__27:		.quad 0x03e40000000000000	# 2p-27
+			.quad 0x03e40000000000000
+.L__real_3fe0000000000000: .quad 0x03fe0000000000000	# 0.5
+			.quad 0x03fe0000000000000
+.L__real_3fc5555555555555: .quad 0x03fc5555555555555	# 0.166666666666
+			.quad 0x03fc5555555555555
+.L__real_3fe45f306dc9c883: .quad 0x03fe45f306dc9c883	# twobypi
+			.quad 0x03fe45f306dc9c883
+.L__real_3ff921fb54400000: .quad 0x03ff921fb54400000	# piby2_1
+			.quad 0x03ff921fb54400000
+.L__real_3dd0b4611a626331: .quad 0x03dd0b4611a626331	# piby2_1tail
+			.quad 0x03dd0b4611a626331
+.L__real_3dd0b4611a600000: .quad 0x03dd0b4611a600000	# piby2_2
+			.quad 0x03dd0b4611a600000
+.L__real_3ba3198a2e037073: .quad 0x03ba3198a2e037073	# piby2_2tail
+			.quad 0x03ba3198a2e037073
+.L__real_fffffffff8000000: .quad 0x0fffffffff8000000	# mask for stripping head and tail
+			.quad 0x0fffffffff8000000
+.L__real_8000000000000000:	.quad 0x08000000000000000	# -0  or signbit
+			.quad 0x08000000000000000
+.L__reald_one_one:		.quad 0x00000000100000001	#
+			.quad 0
+.L__reald_two_two:		.quad 0x00000000200000002	#
+			.quad 0
+.L__reald_one_zero:	.quad 0x00000000100000000	# sin_cos_filter
+			.quad 0
+.L__reald_zero_one:	.quad 0x00000000000000001	#
+			.quad 0
+.L__reald_two_zero:	.quad 0x00000000200000000	#
+			.quad 0
+.L__realq_one_one:		.quad 0x00000000000000001	#
+			.quad 0x00000000000000001	#
+.L__realq_two_two:		.quad 0x00000000000000002	#
+			.quad 0x00000000000000002	#
+.L__real_1_x_mask:		.quad 0x0ffffffffffffffff	#
+			.quad 0x03ff0000000000000	#
+.L__real_zero:		.quad 0x00000000000000000	#
+			.quad 0x00000000000000000	#
+.L__real_one:		.quad 0x00000000000000001	#
+			.quad 0x00000000000000001	#
+
+.Lcosarray:
+	.quad	0x03FA5555555502F31		#  0.0416667			c1
+	.quad	0x03FA5555555502F31
+	.quad	0x0BF56C16BF55699D7		# -0.00138889			c2
+	.quad	0x0BF56C16BF55699D7
+	.quad	0x03EFA015C50A93B49		#  2.48016e-005			c3
+	.quad	0x03EFA015C50A93B49
+	.quad	0x0BE92524743CC46B8		# -2.75573e-007			c4
+	.quad	0x0BE92524743CC46B8
+
+.Lsinarray:
+	.quad	0x0BFC555555545E87D		# -0.166667	   		s1
+	.quad	0x0BFC555555545E87D
+	.quad	0x03F811110DF01232D		# 0.00833333	   		s2
+	.quad	0x03F811110DF01232D
+	.quad	0x0BF2A013A88A37196		# -0.000198413			s3
+	.quad	0x0BF2A013A88A37196
+	.quad	0x03EC6DBE4AD1572D5		# 2.75573e-006			s4
+	.quad	0x03EC6DBE4AD1572D5
+
+.Lsincosarray:
+	.quad	0x0BFC555555545E87D		# -0.166667	   		s1
+	.quad	0x03FA5555555502F31		# 0.0416667		   	c1
+	.quad	0x03F811110DF01232D		# 0.00833333	   		s2
+	.quad	0x0BF56C16BF55699D7
+	.quad	0x0BF2A013A88A37196		# -0.000198413			s3
+	.quad	0x03EFA015C50A93B49
+	.quad	0x03EC6DBE4AD1572D5		# 2.75573e-006			s4
+	.quad	0x0BE92524743CC46B8
+
+.Lcossinarray:
+	.quad	0x03FA5555555502F31		# 0.0416667		   	c1
+	.quad	0x0BFC555555545E87D		# -0.166667	   		s1
+	.quad	0x0BF56C16BF55699D7		#				c2
+	.quad	0x03F811110DF01232D
+	.quad	0x03EFA015C50A93B49		#				c3
+	.quad	0x0BF2A013A88A37196
+	.quad	0x0BE92524743CC46B8		#				c4
+	.quad	0x03EC6DBE4AD1572D5
+
+.align 64
+	.Levensin_oddcos_tbl:
+
+		.quad	.Lsinsin_sinsin_piby4		# 0		*	; Done
+		.quad	.Lsinsin_sincos_piby4		# 1		+	; Done
+		.quad	.Lsinsin_cossin_piby4		# 2			; Done
+		.quad	.Lsinsin_coscos_piby4		# 3		+	; Done
+
+		.quad	.Lsincos_sinsin_piby4		# 4			; Done
+		.quad	.Lsincos_sincos_piby4		# 5		*	; Done
+		.quad	.Lsincos_cossin_piby4		# 6			; Done
+		.quad	.Lsincos_coscos_piby4		# 7			; Done
+
+		.quad	.Lcossin_sinsin_piby4		# 8			; Done
+		.quad	.Lcossin_sincos_piby4		# 9			; TBD
+		.quad	.Lcossin_cossin_piby4		# 10		*	; Done
+		.quad	.Lcossin_coscos_piby4		# 11			; Done
+
+		.quad	.Lcoscos_sinsin_piby4		# 12			; Done
+		.quad	.Lcoscos_sincos_piby4		# 13		+	; Done
+		.quad	.Lcoscos_cossin_piby4		# 14			; Done
+		.quad	.Lcoscos_coscos_piby4		# 15		*	; Done
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    .text
+    .align 16
+    .p2align 4,,15
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# define local variable storage offsets
+.equ	p_temp,0		# temporary for get/put bits operation
+.equ	p_temp1,0x10		# temporary for get/put bits operation
+
+.equ	save_xmm6,0x20		# temporary for get/put bits operation
+.equ	save_xmm7,0x30		# temporary for get/put bits operation
+.equ	save_xmm8,0x40		# temporary for get/put bits operation
+.equ	save_xmm9,0x50		# temporary for get/put bits operation
+.equ	save_xmm0,0x60		# temporary for get/put bits operation
+.equ	save_xmm11,0x70		# temporary for get/put bits operation
+.equ	save_xmm12,0x80		# temporary for get/put bits operation
+.equ	save_xmm13,0x90		# temporary for get/put bits operation
+.equ	save_xmm14,0x0A0		# temporary for get/put bits operation
+.equ	save_xmm15,0x0B0		# temporary for get/put bits operation
+
+.equ	r,0x0C0			# pointer to r for remainder_piby2
+.equ	rr,0x0D0		# pointer to r for remainder_piby2
+.equ	region,0x0E0		# pointer to r for remainder_piby2
+
+.equ	r1,0x0F0		# pointer to r for remainder_piby2
+.equ	rr1,0x0100		# pointer to r for remainder_piby2
+.equ	region1,0x0110		# pointer to r for remainder_piby2
+
+.equ	p_temp2,0x0120		# temporary for get/put bits operation
+.equ	p_temp3,0x0130		# temporary for get/put bits operation
+
+.equ	p_temp4,0x0140		# temporary for get/put bits operation
+.equ	p_temp5,0x0150		# temporary for get/put bits operation
+
+.equ	p_original,0x0160		# original x
+.equ	p_mask,0x0170		# original x
+.equ	p_sign_sin,0x0180		# original x
+
+.equ	p_original1,0x0190		# original x
+.equ	p_mask1,0x01A0		# original x
+.equ	p_sign1_sin,0x01B0		# original x
+
+
+.equ	save_r12,0x01C0		# temporary for get/put bits operation
+.equ	save_r13,0x01D0		# temporary for get/put bits operation
+
+.equ	p_sin,0x01E0		# sin
+.equ	p_cos,0x01F0		# cos
+
+.equ	save_rdi,0x0200		# temporary for get/put bits operation
+.equ	save_rsi,0x0210		# temporary for get/put bits operation
+
+.equ	p_sign_cos,0x0220		# Sign of lower cos term
+.equ	p_sign1_cos,0x0230		# Sign of upper cos term
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+.globl __vrs4_sincosf
+    .type   __vrs4_sincosf,@function
+__vrs4_sincosf:
+
+	sub	$0x0248,%rsp
+
+	mov	%r12,save_r12(%rsp)	# save r12
+
+	mov	%r13,save_r13(%rsp)	# save r13
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#STARTMAIN
+
+	movhlps		%xmm0,%xmm8
+	cvtps2pd	%xmm0,%xmm10			# convert input to double.
+	cvtps2pd	%xmm8,%xmm1			# convert input to double.
+
+movdqa	%xmm10,%xmm6
+movdqa	%xmm1,%xmm7
+movapd	.L__real_7fffffffffffffff(%rip),%xmm2
+
+andpd 	%xmm2,%xmm10				#Unsign
+andpd 	%xmm2,%xmm1				#Unsign
+
+mov	%rdi, p_sin(%rsp)			# save address for sin return
+mov	%rsi,  p_cos(%rsp)			# save address for cos return
+
+movd	%xmm10,%rax				#rax is lower arg
+movhpd	%xmm10, p_temp+8(%rsp)			#
+mov    	p_temp+8(%rsp),%rcx			#rcx = upper arg
+
+movd	%xmm1,%r8				#r8 is lower arg
+movhpd	%xmm1, p_temp1+8(%rsp)			#
+mov    	p_temp1+8(%rsp),%r9			#r9 = upper arg
+
+movdqa	%xmm10,%xmm12
+movdqa	%xmm1,%xmm13
+
+pcmpgtd		%xmm6,%xmm12
+pcmpgtd		%xmm7,%xmm13
+movdqa		%xmm12,%xmm6
+movdqa		%xmm13,%xmm7
+psrldq		$4,%xmm12
+psrldq		$4,%xmm13
+psrldq		$8,%xmm6
+psrldq		$8,%xmm7
+
+mov 	$0x3FE921FB54442D18,%rdx			#piby4	+
+mov	$0x411E848000000000,%r10			#5e5	+
+movapd	.L__real_3fe0000000000000(%rip),%xmm4		#0.5 for later use +
+
+por	%xmm6,%xmm12
+por	%xmm7,%xmm13
+
+movd	%xmm12,%r12				#Move Sign to gpr **
+movd	%xmm13,%r13				#Move Sign to gpr **
+
+movapd	%xmm10,%xmm2				#x0
+movapd	%xmm1,%xmm3				#x1
+movapd	%xmm10,%xmm6				#x0
+movapd	%xmm1,%xmm7				#x1
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm2 = x, xmm4 =0.5/t, xmm6 =x
+# xmm3 = x, xmm5 =0.5/t, xmm7 =x
+.align 16
+.Leither_or_both_arg_gt_than_piby4:
+	cmp	%r10,%rax
+	jae	.Lfirst_or_next3_arg_gt_5e5
+
+	cmp	%r10,%rcx
+	jae	.Lsecond_or_next2_arg_gt_5e5
+
+	cmp	%r10,%r8
+	jae	.Lthird_or_fourth_arg_gt_5e5
+
+	cmp	%r10,%r9
+	jae	.Lfourth_arg_gt_5e5
+
+
+#      /* Find out what multiple of piby2 */
+#        npi2  = (int)(x * twobypi + 0.5);
+	movapd	.L__real_3fe45f306dc9c883(%rip),%xmm10
+	mulpd	%xmm10,%xmm2						# * twobypi
+	mulpd	%xmm10,%xmm3						# * twobypi
+
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	addpd	%xmm4,%xmm3						# +0.5, npi2
+
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm10		# piby2_1
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm1		# piby2_1
+
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	cvttpd2dq	%xmm3,%xmm5					# convert packed double to packed integers
+
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm9		# piby2_2
+
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+	cvtdq2pd	%xmm5,%xmm3					# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+
+	movd	%xmm4,%r8						# Region
+	movd	%xmm5,%r9						# Region
+
+#DELETE
+#	mov 	.LQWORD,%rdx PTR __reald_one_zero			;compare value for cossin path
+#DELETE
+
+	mov	%r8,%r10
+	mov	%r9,%r11
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm10						# npi2 * piby2_1;
+       mulpd	%xmm3,%xmm1						# npi2 * piby2_1;
+
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+       mulpd	%xmm3,%xmm9						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm10,%xmm6						# rhead  = x - npi2 * piby2_1;
+       subpd	%xmm1,%xmm7						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm10						# t
+       movapd	%xmm7,%xmm1						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm10						# rhead
+       subpd	%xmm9,%xmm1						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm3		# npi2 * piby2_2tail
+
+       subpd	%xmm10,%xmm6						# t-rhead
+       subpd	%xmm1,%xmm7						# t-rhead
+
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       subpd	%xmm7,%xmm9						# - ((t - rhead) - rtail)
+
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       addpd	%xmm3,%xmm9						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm4  = npi2 (int), xmm10 =rhead, xmm8 =rtail, r8 = region, r10 = region, r12 = Sign
+# xmm5  = npi2 (int), xmm1 =rhead, xmm9 =rtail,  r9 = region, r11 = region, r13 = Sign
+
+	and	.L__reald_one_one(%rip),%r8		#odd/even region for cos/sin
+	and	.L__reald_one_one(%rip),%r9		#odd/even region for cos/sin
+
+# NEW
+
+	#ADDED
+	mov	%r10,%rdi				# npi2 in int
+	mov	%r11,%rsi				# npi2 in int
+	#ADDED
+
+	shr	$1,%r10					# 0 and 1 => 0
+	shr	$1,%r11					# 2 and 3 => 1
+
+	mov	%r10,%rax
+	mov	%r11,%rcx
+
+	#ADDED
+	xor	%r10,%rdi				# xor last 2 bits of region for cos
+	xor	%r11,%rsi				# xor last 2 bits of region for cos
+	#ADDED
+
+	not 	%r12					#~(sign)
+	not 	%r13					#~(sign)
+	and	%r12,%r10				#region & ~(sign)
+	and	%r13,%r11				#region & ~(sign)
+
+	not	%rax					#~(region)
+	not	%rcx					#~(region)
+	not	%r12					#~~(sign)
+	not	%r13					#~~(sign)
+	and	%r12,%rax				#~region & ~~(sign)
+	and	%r13,%rcx				#~region & ~~(sign)
+
+	#ADDED
+	and	.L__reald_one_one(%rip),%rdi		# sign for cos
+	and	.L__reald_one_one(%rip),%rsi		# sign for cos
+	#ADDED
+
+	or	%rax,%r10
+	or	%rcx,%r11
+	and	.L__reald_one_one(%rip),%r10		# sign for sin
+	and	.L__reald_one_one(%rip),%r11		# sign for sin
+
+
+
+
+
+
+
+	mov	%r10,%r12
+	mov	%r11,%r13
+
+	#ADDED
+	mov	%rdi,%rax
+	mov	%rsi,%rcx
+	#ADDED
+
+	and	.L__reald_one_zero(%rip),%r12		#mask out the lower sign bit leaving the upper sign bit
+	and	.L__reald_one_zero(%rip),%r13		#mask out the lower sign bit leaving the upper sign bit
+
+	#ADDED
+	and	.L__reald_one_zero(%rip),%rax		#mask out the lower sign bit leaving the upper sign bit
+	and	.L__reald_one_zero(%rip),%rcx		#mask out the lower sign bit leaving the upper sign bit
+	#ADDED
+
+	shl	$63,%r10				#shift lower sign bit left by 63 bits
+	shl	$63,%r11				#shift lower sign bit left by 63 bits
+	shl	$31,%r12				#shift upper sign bit left by 31 bits
+	shl	$31,%r13				#shift upper sign bit left by 31 bits
+
+	#ADDED
+	shl	$63,%rdi				#shift lower sign bit left by 63 bits
+	shl	$63,%rsi				#shift lower sign bit left by 63 bits
+	shl	$31,%rax				#shift upper sign bit left by 31 bits
+	shl	$31,%rcx				#shift upper sign bit left by 31 bits
+	#ADDED
+
+	mov 	 %r10,p_sign_sin(%rsp)		#write out lower sign bit
+	mov 	 %r12,p_sign_sin+8(%rsp)		#write out upper sign bit
+	mov 	 %r11,p_sign1_sin(%rsp)		#write out lower sign bit
+	mov 	 %r13,p_sign1_sin+8(%rsp)	#write out upper sign bit
+
+	mov 	 %rdi,p_sign_cos(%rsp)		#write out lower sign bit
+	mov 	 %rax,p_sign_cos+8(%rsp)		#write out upper sign bit
+	mov 	 %rsi,p_sign1_cos(%rsp)		#write out lower sign bit
+	mov 	 %rcx,p_sign1_cos+8(%rsp)	#write out upper sign bit
+
+# NEW
+
+# GET_BITS_DP64(rhead-rtail, uy);			   		; originally only rhead
+# xmm4  = Sign, xmm10 =rhead, xmm8 =rtail
+# xmm5  = Sign, xmm1 =rhead, xmm9 =rtail
+	movapd	%xmm10,%xmm6						# rhead
+	movapd	%xmm1,%xmm7						# rhead
+
+	subpd	%xmm8,%xmm10						# r = rhead - rtail
+	subpd	%xmm9,%xmm1						# r = rhead - rtail
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm4  = Sign, xmm10 = r, xmm6 =rhead, xmm8 =rtail
+# xmm5  = Sign, xmm1 = r, xmm7 =rhead, xmm9 =rtail
+
+#	subpd	%xmm10,%xmm6				;rr=rhead-r
+#	subpd	%xmm1,%xmm7				;rr=rhead-r
+
+	mov	%r8,%rax
+	mov	%r9,%rcx
+
+	movapd	%xmm10,%xmm2				# move r for r2
+	movapd	%xmm1,%xmm3				# move r for r2
+
+	mulpd	%xmm10,%xmm2				# r2
+	mulpd	%xmm1,%xmm3				# r2
+
+#	subpd	xmm6, xmm8				;rr=(rhead-r) -rtail
+#	subpd	xmm7, xmm9				;rr=(rhead-r) -rtail
+
+	and	.L__reald_zero_one(%rip),%rax		# region for jump table
+	and	.L__reald_zero_one(%rip),%rcx
+	shr	$31,%r8
+	shr	$31,%r9
+	or	%r8,%rax
+	or	%r9,%rcx
+	shl	$2,%rcx
+	or	%rcx,%rax
+
+
+# HARSHA ADDED
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign_sin   = Sign, p_sign_cos = Sign,  xmm10 = r, xmm2 = r2
+# p_sign1_sin  = Sign, p_sign1_cos = Sign, xmm1 = r,  xmm3 = r2
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	%xmm2,%xmm14					# for x3
+	movapd	%xmm3,%xmm15					# for x3
+
+	movapd	%xmm2,%xmm0					# for r
+	movapd	%xmm3,%xmm11					# for r
+
+	movdqa	.Lcosarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lcosarray+0x30(%rip),%xmm5			# c4
+
+	movapd	.Lcosarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lcosarray+0x10(%rip),%xmm9			# c2
+
+	movdqa	.Lsinarray+0x30(%rip),%xmm6			# c4
+	movdqa	.Lsinarray+0x30(%rip),%xmm7			# c4
+
+	movapd	.Lsinarray+0x10(%rip),%xmm12			# c2
+	movapd	.Lsinarray+0x10(%rip),%xmm13			# c2
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm10,%xmm14					# x3
+	mulpd	%xmm1,%xmm15					# x3
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	mulpd	%xmm2,%xmm6					# c2*x2
+	mulpd	%xmm3,%xmm7					# c2*x2
+
+	mulpd	%xmm2,%xmm12					# c4*x2
+	mulpd	%xmm3,%xmm13					# c4*x2
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm0		# -t=r-1.0	;trash r
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0	;trash r
+
+	mulpd	%xmm2,%xmm2					# x4
+	mulpd	%xmm3,%xmm3					# x4
+
+	addpd	.Lcosarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lcosarray+0x20(%rip),%xmm5			# c3+x2c4
+
+	addpd	.Lcosarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lcosarray(%rip),%xmm9			# c1+x2c2
+
+	addpd	.Lsinarray+0x20(%rip),%xmm6			# c3+x2c4
+	addpd	.Lsinarray+0x20(%rip),%xmm7			# c3+x2c4
+
+	addpd	.Lsinarray(%rip),%xmm12			# c1+x2c2
+	addpd	.Lsinarray(%rip),%xmm13			# c1+x2c2
+
+	mulpd	%xmm2,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm3,%xmm5					# x4(c3+x2c4)
+
+	mulpd	%xmm2,%xmm6					# x4(c3+x2c4)
+	mulpd	%xmm3,%xmm7					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zc
+
+	addpd	%xmm12,%xmm6					# zs
+	addpd	%xmm13,%xmm7					# zs
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x4 * zc
+
+	mulpd	%xmm14,%xmm6					# x3 * zs
+	mulpd	%xmm15,%xmm7					# x3 * zs
+
+	subpd   %xmm0,%xmm4					# - (-t)
+	subpd   %xmm11,%xmm5					# - (-t)
+
+	addpd	%xmm10,%xmm6					# +x
+	addpd	%xmm1,%xmm7					# +x
+
+# HARSHA ADDED
+
+	lea	.Levensin_oddcos_tbl(%rip),%rcx
+	jmp	*(%rcx,%rax,8)					#Jmp table for cos/sin calculation based on even/odd region
+
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lfirst_or_next3_arg_gt_5e5:
+# %rcx,,%rax r8, r9
+
+	cmp	%r10,%rcx				#is upper arg >= 5e5
+	jae	.Lboth_arg_gt_5e5
+
+.Llower_arg_gt_5e5:
+# Upper Arg is < 5e5, Lower arg is >= 5e5
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+# Be sure not to use %xmm3,%xmm1 and xmm7
+# Use %xmm8,,%xmm5 xmm0, xmm12
+#	    %xmm11,,%xmm9 xmm13
+
+
+	movlpd	 %xmm10,r(%rsp)		#Save lower fp arg for remainder_piby2 call
+	movhlps	%xmm10,%xmm10			#Needed since we want to work on upper arg
+	movhlps	%xmm2,%xmm2
+	movhlps	%xmm6,%xmm6
+
+# Work on Upper arg
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm4,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm8		# xmm8 = piby2_1
+	cvttsd2si	%xmm2,%ecx				# ecx = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm0		# xmm0 = piby2_2
+	cvtsi2sd	%ecx,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm8					# npi2 * piby2_1
+	subsd	%xmm8,%xmm6					# xmm6 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm12		# xmm12 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm6,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm0					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm0,%xmm6					# xmm6 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm12     					# npi2 * piby2_2tail
+       subsd	%xmm6,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm0					# (rtail-(t-rhead))
+       addsd	%xmm12,%xmm0					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %ecx,region+4(%rsp)			# store upper region
+       movsd	%xmm6,%xmm10
+       subsd	%xmm0,%xmm10					# xmm10 = r=(rhead-rtail)
+       subsd	%xmm10,%xmm6					# rr=rhead-r
+       subsd	%xmm0,%xmm6					# xmm6 = rr=((rhead-r) -rtail)
+       movlpd	 %xmm10,r+8(%rsp)			# store upper r
+       movlpd	 %xmm6,rr+8(%rsp)			# store upper rr
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#Note that volatiles will be trashed by the call
+#We will construct r, rr, region and sign
+
+# Work on Lower arg
+	mov		$0x07ff0000000000000,%r11			# is lower arg nan/inf
+	mov		%r11,%r10
+	and		%rax,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sincosf_lower_naninf
+
+	mov	  %r8,p_temp(%rsp)
+	mov	  %r9,p_temp2(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region(%rsp),%rdx			# lower arg is **NOT** nan/inf
+	lea	 r(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	mov	 r(%rsp),%rdi				#Restore lower fp arg for remainder_piby2 call
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	 p_temp(%rsp),%r8
+	mov	 p_temp2(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+	jmp 	0f
+
+.L__vrs4_sincosf_lower_naninf:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rax
+	mov	 %rax,r(%rsp)				# r = x | 0x0008000000000000
+	mov	 %r10d,region(%rsp)			# region =0
+
+.align 16
+0:
+
+	jmp 	.Lcheck_next2_args
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lboth_arg_gt_5e5:
+#Upper Arg is >= 5e5, Lower arg is >= 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+
+	movhlps %xmm10,%xmm6		#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r11			#is lower arg nan/inf
+	mov		%r11,%r10
+	and		%rax,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sincosf_lower_naninf_of_both_gt_5e5
+
+	mov	  %rcx,p_temp(%rsp)			#Save upper arg
+	mov	  %r8,p_temp2(%rsp)
+	mov	  %r9,p_temp4(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	 r(%rsp),%rsi
+
+# added ins- changed input from xmm10 to xmm0
+	movd	%xmm10,%rdi
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	 p_temp2(%rsp),%r8
+	mov	 p_temp4(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+
+	mov	 p_temp(%rsp),%rcx			#Restore upper arg
+	jmp 	0f
+
+.L__vrs4_sincosf_lower_naninf_of_both_gt_5e5:				#lower arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rax
+	mov	 %rax,r(%rsp)				#r = x | 0x0008000000000000
+	mov	 %r10d,region(%rsp)			#region = 0
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r11			#is upper arg nan/inf
+	mov		%r11,%r10
+	and		%rcx,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sincosf_upper_naninf_of_both_gt_5e5
+
+
+	mov	  %r8,p_temp2(%rsp)
+	mov	  %r9,p_temp4(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region+4(%rsp),%rdx			#upper arg is **NOT** nan/inf
+	lea	 r+8(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	movd	 %xmm6,%rdi				#Restore upper fp arg for remainder_piby2 call
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	 p_temp2(%rsp),%r8
+	mov	 p_temp4(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+
+	jmp 	0f
+
+.L__vrs4_sincosf_upper_naninf_of_both_gt_5e5:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rcx
+	mov	 %rcx,r+8(%rsp)				#r = x | 0x0008000000000000
+	mov	 %r10d,region+4(%rsp)			#region = 0
+
+.align 16
+0:
+	jmp 	.Lcheck_next2_args
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lsecond_or_next2_arg_gt_5e5:
+
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+# Do not use %xmm3,,%xmm1 xmm7
+# Restore xmm4 and %xmm3,,%xmm1 xmm7
+# Can use %xmm0,,%xmm8 xmm12
+#   %xmm9,,%xmm5 xmm11, xmm13
+
+	movhpd	 %xmm10,r+8(%rsp)	#Save upper fp arg for remainder_piby2 call
+
+# Work on Lower arg
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm4,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm8		# xmm3 = piby2_1
+	cvttsd2si	%xmm2,%eax				# ecx = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm0		# xmm1 = piby2_2
+	cvtsi2sd	%eax,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm8					# npi2 * piby2_1
+	subsd	%xmm8,%xmm6					# xmm6 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm12		# xmm7 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm6,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm0					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm0,%xmm6					# xmm6 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm12     					# npi2 * piby2_2tail
+       subsd	%xmm6,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm0					# (rtail-(t-rhead))
+       addsd	%xmm12,%xmm0					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %eax,region(%rsp)			# store upper region
+
+#       movsd	%xmm6,%xmm10
+#       subsd	xmm10,xmm0					; xmm10 = r=(rhead-rtail)
+#       subsd	%xmm10,%xmm6					; rr=rhead-r
+#       subsd	xmm6, xmm0					; xmm6 = rr=((rhead-r) -rtail)
+
+        subsd	%xmm0,%xmm6					# xmm10 = r=(rhead-rtail)
+
+#       movlpd	QWORD PTR r[rsp], xmm10				; store upper r
+#       movlpd	QWORD PTR rr[rsp], xmm6				; store upper rr
+
+        movlpd	 %xmm6,r(%rsp)				# store upper r
+
+
+#Work on Upper arg
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+	mov		$0x07ff0000000000000,%r11			# is upper arg nan/inf
+	mov		%r11,%r10
+	and		%rcx,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sincosf_upper_naninf
+
+	mov	 %r8,p_temp(%rsp)
+	mov	 %r9,p_temp2(%rsp)
+	movapd	 %xmm1,p_temp1(%rsp)
+	movapd	 %xmm3,p_temp3(%rsp)
+	movapd	 %xmm7,p_temp5(%rsp)
+
+	lea	 region+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 r+8(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	mov	 r+8(%rsp),%rdi				#Restore upper fp arg for remainder_piby2 call
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	p_temp(%rsp),%r8
+	mov	p_temp2(%rsp),%r9
+	movapd	p_temp1(%rsp),%xmm1
+	movapd	p_temp3(%rsp),%xmm3
+	movapd	p_temp5(%rsp),%xmm7
+	jmp 	0f
+
+.L__vrs4_sincosf_upper_naninf:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rcx
+	mov	 %rcx,r+8(%rsp)				# r = x | 0x0008000000000000
+	mov	 %r10d,region+4(%rsp)			# region =0
+
+.align 16
+0:
+
+	jmp	.Lcheck_next2_args
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcheck_next2_args:
+
+	mov	$0x411E848000000000,%r10			#5e5	+
+
+	cmp	%r10,%r8
+	jae	.Lfirst_second_done_third_or_fourth_arg_gt_5e5
+
+	cmp	%r10,%r9
+	jae	.Lfirst_second_done_fourth_arg_gt_5e5
+
+
+
+# Work on next two args, both < 5e5
+# %xmm3,,%xmm1 xmm5 = x, xmm4 = 0.5
+
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4			#Restore 0.5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm3						# * twobypi
+	addpd	%xmm4,%xmm3						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm1		# piby2_1
+	cvttpd2dq	%xmm3,%xmm5					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm9		# piby2_2
+	cvtdq2pd	%xmm5,%xmm3					# and back to double.
+
+###
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movlpd	 %xmm5,region1(%rsp)						# Region
+###
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm3,%xmm1						# npi2 * piby2_1;
+
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm3,%xmm9						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm1,%xmm7						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm7,%xmm1						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm9,%xmm1						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm3		# npi2 * piby2_2tail
+
+       subpd	%xmm1,%xmm7						# t-rhead
+       subpd	%xmm7,%xmm9						# - ((t - rhead) - rtail)
+       addpd	%xmm3,%xmm9						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+#       movapd	%xmm1,%xmm7						; rhead
+       subpd	%xmm9,%xmm1						# r = rhead - rtail
+       movapd	 %xmm1,r1(%rsp)
+
+#       subpd	%xmm1,%xmm7						; rr=rhead-r
+#       subpd	xmm7, xmm9						; rr=(rhead-r) -rtail
+#       movapd	OWORD PTR rr1[rsp], xmm7
+
+	jmp	.L__vrs4_sincosf_reconstruct
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lthird_or_fourth_arg_gt_5e5:
+#first two args are < 5e5, third arg >= 5e5, fourth arg >= 5e5 or < 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+# Do not use %xmm3,,%xmm1 xmm7
+# Can use 	%xmm11,,%xmm9 xmm13
+# 	%xmm8,,%xmm5 xmm0, xmm12
+# Restore xmm4
+
+# Work on first two args, both < 5e5
+
+
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# * twobypi
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm10		# piby2_1
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+
+###
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movlpd	 %xmm4,region(%rsp)				# Region
+###
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm10						# npi2 * piby2_1;
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm10,%xmm6						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm10						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm10						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+
+       subpd	%xmm10,%xmm6						# t-rhead
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+#       movapd	%xmm10,%xmm6						; rhead
+       subpd	%xmm8,%xmm10						# r = rhead - rtail
+       movapd	 %xmm10,r(%rsp)
+
+#       subpd	%xmm10,%xmm6						; rr=rhead-r
+#       subpd	xmm6, xmm8						; rr=(rhead-r) -rtail
+#       movapd	OWORD PTR rr[rsp], xmm6
+
+
+# Work on next two args, third arg >= 5e5, fourth arg >= 5e5 or < 5e5
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lfirst_second_done_third_or_fourth_arg_gt_5e5:
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+
+
+	mov	$0x411E848000000000,%r10			#5e5	+
+	cmp	%r10,%r9
+	jae	.Lboth_arg_gt_5e5_higher
+
+
+# Upper Arg is <5e5, Lower arg is >= 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+	movlpd	 %xmm1,r1(%rsp)		#Save lower fp arg for remainder_piby2 call
+	movhlps	%xmm1,%xmm1			#Needed since we want to work on upper arg
+	movhlps	%xmm3,%xmm3
+	movhlps	%xmm7,%xmm7
+
+
+# Work on Upper arg
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4		# Restore 0.5
+
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm3		# x*twobypi
+	addsd	%xmm4,%xmm3					# xmm3 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm2		# xmm2 = piby2_1
+	cvttsd2si	%xmm3,%r9d				# r9d = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm10		# xmm10 = piby2_2
+	cvtsi2sd	%r9d,%xmm3				# xmm3 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm3,%xmm2					# npi2 * piby2_1
+	subsd	%xmm2,%xmm7					# xmm7 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm7,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm3,%xmm10					# xmm10 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm10,%xmm7					# xmm7 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm3,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm7,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm10					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm10					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %r9d,region1+4(%rsp)			# store upper region
+
+
+       subsd	%xmm10,%xmm7					# xmm1 = r=(rhead-rtail)
+
+       movlpd	 %xmm7,r1+8(%rsp)			# store upper r
+
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+
+# Work on Lower arg
+	mov		$0x07ff0000000000000,%r11			# is lower arg nan/inf
+	mov		%r11,%r10
+	and		%r8,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sincosf_lower_naninf_higher
+
+	lea	 region1(%rsp),%rdx			# lower arg is **NOT** nan/inf
+	lea	 r1(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	mov	 r1(%rsp),%rdi				#Restore lower fp arg for remainder_piby2 call
+
+	call	 __remainder_piby2d2f@PLT
+
+	jmp 	0f
+
+.L__vrs4_sincosf_lower_naninf_higher:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r8
+	mov	 %r8,r1(%rsp)				# r = x | 0x0008000000000000
+	mov	 %r10d,region1(%rsp)			# region =0
+
+.align 16
+0:
+	jmp 	.L__vrs4_sincosf_reconstruct
+
+
+
+
+
+
+
+.align 16
+.Lboth_arg_gt_5e5_higher:
+# Upper Arg is >= 5e5, Lower arg is >= 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+
+	movhlps %xmm1,%xmm7		#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r11			#is lower arg nan/inf
+	mov		%r11,%r10
+	and		%r8,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sincosf_lower_naninf_of_both_gt_5e5_higher
+
+	mov	  %r9,p_temp1(%rsp)			#Save upper arg
+	lea	  region1(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	  r1(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	movd	 %xmm1,%rdi
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	 p_temp1(%rsp),%r9			#Restore upper arg
+
+
+	jmp 	0f
+
+.L__vrs4_sincosf_lower_naninf_of_both_gt_5e5_higher:				#lower arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r8
+	mov	 %r8,r1(%rsp)				#r = x | 0x0008000000000000
+	mov	 %r10d,region1(%rsp)			#region = 0
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r11			#is upper arg nan/inf
+	mov		%r11,%r10
+	and		%r9,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sincosf_upper_naninf_of_both_gt_5e5_higher
+
+	lea	 region1+4(%rsp),%rdx			#upper arg is **NOT** nan/inf
+	lea	 r1+8(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	movd	 %xmm7,%rdi			#Restore upper fp arg for remainder_piby2 call
+
+
+	call	 __remainder_piby2d2f@PLT
+
+	jmp 	0f
+
+.L__vrs4_sincosf_upper_naninf_of_both_gt_5e5_higher:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r9
+	mov	 %r9,r1+8(%rsp)				#r = x | 0x0008000000000000
+	mov	 %r10d,region1+4(%rsp)			#region = 0
+
+.align 16
+0:
+
+	jmp 	.L__vrs4_sincosf_reconstruct
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lfourth_arg_gt_5e5:
+#first two args are < 5e5, third arg < 5e5, fourth arg >= 5e5
+#%rcx,,%rax r8, r9
+#%xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+
+# Work on first two args, both < 5e5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# * twobypi
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm10		# piby2_1
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+
+###
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movlpd	 %xmm4,region(%rsp)				# Region
+###
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm10						# npi2 * piby2_1;
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm10,%xmm6						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm10						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm10						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+
+       subpd	%xmm10,%xmm6						# t-rhead
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+#       movapd	%xmm10,%xmm6						; rhead
+       subpd	%xmm8,%xmm10						# r = rhead - rtail
+       movapd	 %xmm10,r(%rsp)
+
+#       subpd	%xmm10,%xmm6						; rr=rhead-r
+#       subpd	xmm6, xmm8						; rr=(rhead-r) -rtail
+#       movapd	OWORD PTR rr[rsp], xmm6
+
+
+# Work on next two args, third arg < 5e5, fourth arg >= 5e5
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lfirst_second_done_fourth_arg_gt_5e5:
+
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+	movhpd	 %xmm1,r1+8(%rsp)	#Save upper fp arg for remainder_piby2 call
+
+
+# Work on Lower arg
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4		# Restore 0.5
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm3		# x*twobypi
+	addsd	%xmm4,%xmm3					# xmm3 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm2		# xmm2 = piby2_1
+	cvttsd2si	%xmm3,%r8d				# r8d = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm10		# xmm10 = piby2_2
+	cvtsi2sd	%r8d,%xmm3				# xmm3 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm3,%xmm2					# npi2 * piby2_1
+	subsd	%xmm2,%xmm7					# xmm7 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm7,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm3,%xmm10					# xmm10 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm10,%xmm7					# xmm7 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm3,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm7,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm10					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm10					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %r8d,region1(%rsp)			# store lower region
+
+#       movsd	%xmm7,%xmm1
+#       subsd	xmm1, xmm10					; xmm10 = r=(rhead-rtail)
+#       subsd	%xmm1,%xmm7					; rr=rhead-r
+#       subsd	xmm7, xmm10					; xmm6 = rr=((rhead-r) -rtail)
+
+        subsd	%xmm10,%xmm7					# xmm10 = r=(rhead-rtail)
+
+#       movlpd	QWORD PTR r1[rsp], xmm1				; store upper r
+#       movlpd	QWORD PTR rr1[rsp], xmm7			; store upper rr
+
+        movlpd	 %xmm7,r1(%rsp)				# store upper r
+
+#Work on Upper arg
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+	mov		$0x07ff0000000000000,%r11			# is upper arg nan/inf
+	mov		%r11,%r10
+	and		%r9,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sincosf_upper_naninf_higher
+
+	lea	 region1+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 r1+8(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	mov	 r1+8(%rsp),%rdi				#Restore upper fp arg for remainder_piby2 call
+
+	call	 __remainder_piby2d2f@PLT
+
+	jmp 	0f
+
+.L__vrs4_sincosf_upper_naninf_higher:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r9
+	mov	 %r9,r1+8(%rsp)				# r = x | 0x0008000000000000
+	mov	 %r10d,region1+4(%rsp)			# region =0
+
+.align 16
+0:
+	jmp	.L__vrs4_sincosf_reconstruct
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrs4_sincosf_reconstruct:
+#Results
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign_sin  = Sign,  ; p_sign_cos   = Sign, xmm10 = r, xmm2 = r2
+# p_sign1_sin  = Sign, ; p_sign1_cos  = Sign, xmm1 = r, xmm3 = r2
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	r(%rsp),%xmm10
+	movapd	r1(%rsp),%xmm1
+
+	mov	region(%rsp),%r8
+	mov	region1(%rsp),%r9
+
+	mov 	%r8,%r10
+	mov 	%r9,%r11
+
+	and	.L__reald_one_one(%rip),%r8		#odd/even region for cos/sin
+	and	.L__reald_one_one(%rip),%r9		#odd/even region for cos/sin
+
+
+# NEW
+
+	#ADDED
+	mov	%r10,%rdi
+	mov	%r11,%rsi
+	#ADDED
+
+	shr	$1,%r10						#~AB+A~B, A is sign and B is upper bit of region
+	shr	$1,%r11						#~AB+A~B, A is sign and B is upper bit of region
+
+	mov	%r10,%rax
+	mov	%r11,%rcx
+
+	#ADDED
+	xor	%r10,%rdi
+	xor	%r11,%rsi
+	#ADDED
+
+	not 	%r12						#ADDED TO CHANGE THE LOGIC
+	not 	%r13						#ADDED TO CHANGE THE LOGIC
+	and	%r12,%r10
+	and	%r13,%r11
+
+	not	%rax
+	not	%rcx
+	not	%r12
+	not	%r13
+	and	%r12,%rax
+	and	%r13,%rcx
+
+	#ADDED
+	and	.L__reald_one_one(%rip),%rdi				#(~AB+A~B)&1
+	and	.L__reald_one_one(%rip),%rsi				#(~AB+A~B)&1
+	#ADDED
+
+	or	%rax,%r10
+	or	%rcx,%r11
+	and	.L__reald_one_one(%rip),%r10				#(~AB+A~B)&1
+	and	.L__reald_one_one(%rip),%r11				#(~AB+A~B)&1
+
+
+
+
+
+
+
+	mov	%r10,%r12
+	mov	%r11,%r13
+
+	#ADDED
+	mov	%rdi,%rax
+	mov	%rsi,%rcx
+	#ADDED
+
+	and	.L__reald_one_zero(%rip),%r12		#mask out the lower sign bit leaving the upper sign bit
+	and	.L__reald_one_zero(%rip),%r13		#mask out the lower sign bit leaving the upper sign bit
+
+	#ADDED
+	and	.L__reald_one_zero(%rip),%rax		#mask out the lower sign bit leaving the upper sign bit
+	and	.L__reald_one_zero(%rip),%rcx		#mask out the lower sign bit leaving the upper sign bit
+	#ADDED
+
+	shl	$63,%r10				#shift lower sign bit left by 63 bits
+	shl	$63,%r11				#shift lower sign bit left by 63 bits
+	shl	$31,%r12				#shift upper sign bit left by 31 bits
+	shl	$31,%r13				#shift upper sign bit left by 31 bits
+
+	#ADDED
+	shl	$63,%rdi				#shift lower sign bit left by 63 bits
+	shl	$63,%rsi				#shift lower sign bit left by 63 bits
+	shl	$31,%rax				#shift upper sign bit left by 31 bits
+	shl	$31,%rcx				#shift upper sign bit left by 31 bits
+	#ADDED
+
+	mov 	 %r10,p_sign_sin(%rsp)		#write out lower sign bit
+	mov 	 %r12,p_sign_sin+8(%rsp)		#write out upper sign bit
+	mov 	 %r11,p_sign1_sin(%rsp)		#write out lower sign bit
+	mov 	 %r13,p_sign1_sin+8(%rsp)	#write out upper sign bit
+
+	mov 	 %rdi,p_sign_cos(%rsp)		#write out lower sign bit
+	mov 	 %rax,p_sign_cos+8(%rsp)		#write out upper sign bit
+	mov 	 %rsi,p_sign1_cos(%rsp)		#write out lower sign bit
+	mov 	 %rcx,p_sign1_cos+8(%rsp)	#write out upper sign bit
+#NEW
+
+
+	mov	%r8,%rax
+	mov	%r9,%rcx
+
+	movapd	%xmm10,%xmm2
+	movapd	%xmm1,%xmm3
+
+	mulpd	%xmm10,%xmm2				# r2
+	mulpd	%xmm1,%xmm3				# r2
+
+	and	.L__reald_zero_one(%rip),%rax
+	and	.L__reald_zero_one(%rip),%rcx
+	shr	$31,%r8
+	shr	$31,%r9
+	or	%r8,%rax
+	or	%r9,%rcx
+	shl	$2,%rcx
+	or	%rcx,%rax
+
+
+# HARSHA ADDED
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign_cos  = Sign, p_sign_sin  = Sign, xmm10 = r, xmm2 = r2
+# p_sign1_cos = Sign, p_sign1_sin = Sign, xmm1 = r,  xmm3 = r2
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	%xmm2,%xmm14					# for x3
+	movapd	%xmm3,%xmm15					# for x3
+
+	movapd	%xmm2,%xmm0					# for r
+	movapd	%xmm3,%xmm11					# for r
+
+	movdqa	.Lcosarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lcosarray+0x30(%rip),%xmm5			# c4
+
+	movapd	.Lcosarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lcosarray+0x10(%rip),%xmm9			# c2
+
+	movdqa	.Lsinarray+0x30(%rip),%xmm6			# c4
+	movdqa	.Lsinarray+0x30(%rip),%xmm7			# c4
+
+	movapd	.Lsinarray+0x10(%rip),%xmm12			# c2
+	movapd	.Lsinarray+0x10(%rip),%xmm13			# c2
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm10,%xmm14					# x3
+	mulpd	%xmm1,%xmm15					# x3
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	mulpd	%xmm2,%xmm6					# c2*x2
+	mulpd	%xmm3,%xmm7					# c2*x2
+
+	mulpd	%xmm2,%xmm12					# c4*x2
+	mulpd	%xmm3,%xmm13					# c4*x2
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm0		# -t=r-1.0	;trash r
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0	;trash r
+
+	mulpd	%xmm2,%xmm2					# x4
+	mulpd	%xmm3,%xmm3					# x4
+
+	addpd	.Lcosarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lcosarray+0x20(%rip),%xmm5			# c3+x2c4
+
+	addpd	.Lcosarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lcosarray(%rip),%xmm9			# c1+x2c2
+
+	addpd	.Lsinarray+0x20(%rip),%xmm6			# c3+x2c4
+	addpd	.Lsinarray+0x20(%rip),%xmm7			# c3+x2c4
+
+	addpd	.Lsinarray(%rip),%xmm12			# c1+x2c2
+	addpd	.Lsinarray(%rip),%xmm13			# c1+x2c2
+
+	mulpd	%xmm2,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm3,%xmm5					# x4(c3+x2c4)
+
+	mulpd	%xmm2,%xmm6					# x4(c3+x2c4)
+	mulpd	%xmm3,%xmm7					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zc
+
+	addpd	%xmm12,%xmm6					# zs
+	addpd	%xmm13,%xmm7					# zs
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x4 * zc
+
+	mulpd	%xmm14,%xmm6					# x3 * zs
+	mulpd	%xmm15,%xmm7					# x3 * zs
+
+	subpd   %xmm0,%xmm4					# - (-t)
+	subpd   %xmm11,%xmm5					# - (-t)
+
+	addpd	%xmm10,%xmm6					# +x
+	addpd	%xmm1,%xmm7					# +x
+
+# HARSHA ADDED
+
+
+	lea	.Levensin_oddcos_tbl(%rip),%rcx
+	jmp	*(%rcx,%rax,8)					#Jmp table for cos/sin calculation based on even/odd region
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrs4_sincosf_cleanup:
+
+	mov	p_sin(%rsp),%rdi
+	mov	p_cos(%rsp),%rsi
+
+	movapd	  p_sign_cos(%rsp),%xmm10
+	movapd	  p_sign1_cos(%rsp),%xmm1
+
+
+	xorpd	%xmm4,%xmm10			# Cos term   (+) Sign
+	xorpd	%xmm5,%xmm1			# Cos term   (+) Sign
+
+	cvtpd2ps %xmm10,%xmm0
+	cvtpd2ps %xmm1,%xmm11
+
+	movapd	  p_sign_sin(%rsp),%xmm14
+	movapd	  p_sign1_sin(%rsp),%xmm15
+
+	xorpd	%xmm6,%xmm14			# Sin term (+) Sign
+	xorpd	%xmm7,%xmm15			# Sin term (+) Sign
+
+	cvtpd2ps %xmm14,%xmm12
+	cvtpd2ps %xmm15,%xmm13
+
+	movlps	 %xmm0,(%rsi) 				# save the cos
+	movlps	 %xmm12,(%rdi) 				# save the sin
+	movlps	 %xmm11,8(%rsi)				# save the cos
+	movlps	 %xmm13,8(%rdi)			# save the sin
+
+	mov	save_r12(%rsp),%r12	# restore r12
+	mov	save_r13(%rsp),%r13	# restore r13
+
+	add	$0x0248,%rsp
+	ret
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;JUMP TABLE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+.align 16
+.Lcoscos_coscos_piby4:
+# Cos in %xmm5,%xmm4
+# Sin in %xmm7,%xmm6
+# Lower and Upper Even
+
+	movapd	%xmm4,%xmm8
+	movapd	%xmm5,%xmm9
+
+	movapd	%xmm6,%xmm4
+	movapd	%xmm7,%xmm5
+
+	movapd	%xmm8,%xmm6
+	movapd	%xmm9,%xmm7
+
+	jmp 	.L__vrs4_sincosf_cleanup
+
+.align 16
+.Lcossin_cossin_piby4:
+
+	movhlps	%xmm5,%xmm9
+	movhlps	%xmm7,%xmm13
+
+	movlhps	%xmm9,%xmm7
+	movlhps	%xmm13,%xmm5
+
+	movhlps	%xmm4,%xmm8
+	movhlps	%xmm6,%xmm12
+
+	movlhps	%xmm8,%xmm6
+	movlhps	%xmm12,%xmm4
+
+	jmp 	.L__vrs4_sincosf_cleanup
+
+.align 16
+.Lsincos_cossin_piby4:
+	movsd	%xmm5,%xmm9
+	movsd	%xmm7,%xmm13
+
+	movsd	%xmm9,%xmm7
+	movsd	%xmm13,%xmm5
+
+	movhlps	%xmm4,%xmm8
+	movhlps	%xmm6,%xmm12
+
+	movlhps	%xmm8,%xmm6
+	movlhps	%xmm12,%xmm4
+
+	jmp	.L__vrs4_sincosf_cleanup
+
+.align 16
+.Lsincos_sincos_piby4:
+	movsd	%xmm5,%xmm9
+	movsd	%xmm7,%xmm13
+
+	movsd	%xmm9,%xmm7
+	movsd	%xmm13,%xmm5
+
+	movsd	%xmm4,%xmm8
+	movsd	%xmm6,%xmm12
+
+	movsd	%xmm8,%xmm6
+	movsd	%xmm12,%xmm4
+
+	jmp 	.L__vrs4_sincosf_cleanup
+
+.align 16
+.Lcossin_sincos_piby4:
+	movhlps	%xmm5,%xmm9
+	movhlps	%xmm7,%xmm13
+
+	movlhps	%xmm9,%xmm7
+	movlhps	%xmm13,%xmm5
+
+	movsd	%xmm4,%xmm8
+	movsd	%xmm6,%xmm12
+
+	movsd	%xmm8,%xmm6
+	movsd	%xmm12,%xmm4
+
+	jmp	.L__vrs4_sincosf_cleanup
+
+.align 16
+.Lcoscos_sinsin_piby4:
+# Cos in %xmm5,%xmm4
+# Sin in %xmm7,%xmm6
+# Lower even, Upper odd, Swap upper
+
+	movapd	%xmm5,%xmm9
+	movapd	%xmm7,%xmm5
+	movapd	%xmm9,%xmm7
+
+	jmp 	.L__vrs4_sincosf_cleanup
+
+.align 16
+.Lsinsin_coscos_piby4:
+# Cos in %xmm5,%xmm4
+# Sin in %xmm7,%xmm6
+# Lower odd, Upper even, Swap lower
+
+	movapd	%xmm4,%xmm8
+	movapd	%xmm6,%xmm4
+	movapd	%xmm8,%xmm6
+
+	jmp 	.L__vrs4_sincosf_cleanup
+
+.align 16
+.Lcoscos_cossin_piby4:
+# Cos in xmm4 and xmm5
+# Sin in xmm6 and xmm7
+
+	movapd	%xmm5,%xmm9
+	movapd	%xmm7,%xmm5
+	movapd	%xmm9,%xmm7
+
+	movhlps	%xmm4,%xmm8
+	movhlps	%xmm6,%xmm12
+
+	movlhps	%xmm8,%xmm6
+	movlhps	%xmm12,%xmm4
+
+	jmp 	.L__vrs4_sincosf_cleanup
+
+.align 16
+.Lcoscos_sincos_piby4:
+# Cos in xmm4 and xmm5
+# Sin in xmm6 and xmm7
+
+	movapd	%xmm5,%xmm9
+	movapd	%xmm7,%xmm5
+	movapd	%xmm9,%xmm7
+
+	movsd	%xmm4,%xmm8
+	movsd	%xmm6,%xmm12
+
+	movsd	%xmm8,%xmm6
+	movsd	%xmm12,%xmm4
+	jmp 	.L__vrs4_sincosf_cleanup
+
+.align 16
+.Lcossin_coscos_piby4:
+# Cos in xmm4 and xmm5
+# Sin in xmm6 and xmm7
+
+	movapd	%xmm4,%xmm8
+	movapd	%xmm6,%xmm4
+	movapd	%xmm8,%xmm6
+
+	movhlps	%xmm5,%xmm9
+	movhlps	%xmm7,%xmm13
+
+	movlhps	%xmm9,%xmm7
+	movlhps	%xmm13,%xmm5
+
+	jmp 	.L__vrs4_sincosf_cleanup
+
+.align 16
+.Lcossin_sinsin_piby4:
+# Cos in xmm4 and xmm5
+# Sin in xmm6 and xmm7
+	movhlps	%xmm5,%xmm9
+	movhlps	%xmm7,%xmm13
+
+	movlhps	%xmm9,%xmm7
+	movlhps	%xmm13,%xmm5
+
+	jmp 	.L__vrs4_sincosf_cleanup
+
+
+.align 16
+.Lsincos_coscos_piby4:
+# Cos in xmm4 and xmm5
+# Sin in xmm6 and xmm7
+	movapd	%xmm4,%xmm8
+	movapd	%xmm6,%xmm4
+	movapd	%xmm8,%xmm6
+
+	movsd	%xmm5,%xmm9
+	movsd	%xmm7,%xmm13
+
+	movsd	%xmm9,%xmm7
+	movsd	%xmm13,%xmm5
+	jmp 	.L__vrs4_sincosf_cleanup
+
+.align 16
+.Lsincos_sinsin_piby4:
+# Cos in xmm4 and xmm5
+# Sin in xmm6 and xmm7
+	movsd	%xmm5,%xmm9
+	movsd	%xmm7,%xmm5
+	movsd	%xmm9,%xmm7
+
+	jmp 	.L__vrs4_sincosf_cleanup
+
+.align 16
+.Lsinsin_cossin_piby4:
+# Cos in xmm4 and xmm5
+# Sin in xmm6 and xmm7
+	movhlps	%xmm4,%xmm8
+	movhlps	%xmm6,%xmm12
+
+	movlhps	%xmm8,%xmm6
+	movlhps	%xmm12,%xmm4
+
+	jmp 	.L__vrs4_sincosf_cleanup
+
+.align 16
+.Lsinsin_sincos_piby4:
+# Cos in xmm4 and xmm5
+# Sin in xmm6 and xmm7
+	movsd	%xmm4,%xmm8
+	movsd	%xmm6,%xmm4
+	movsd	%xmm8,%xmm6
+	jmp 	.L__vrs4_sincosf_cleanup
+
+.align 16
+.Lsinsin_sinsin_piby4:
+# Cos in xmm4 and xmm5
+# Sin in xmm6 and xmm7
+# Lower and Upper odd, So Swap
+
+	jmp 	.L__vrs4_sincosf_cleanup
diff --git a/src/gas/vrs4sinf.S b/src/gas/vrs4sinf.S
new file mode 100644
index 0000000..3744f33
--- /dev/null
+++ b/src/gas/vrs4sinf.S
@@ -0,0 +1,2171 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrs4sinf.s
+#
+# A vector implementation of the sin libm function.
+#
+# Prototype:
+#
+#    __m128 __vrs4_sinf(__m128 x);
+#
+# Computes Sine of x for an array of input values.
+# Places the results into the supplied y array.
+# Does not perform error checking.
+# Denormal inputs may produce unexpected results.
+# This routine computes 4 single precision Sine values at a time.
+# The four values are passed as packed single in xmm10.
+# The four results are returned as packed singles in xmm10.
+# Note that this represents a non-standard ABI usage, as no ABI
+# ( and indeed C) currently allows returning 2 values for a function.
+# It is expected that some compilers may be able to take advantage of this
+# interface when implementing vectorized loops.  Using the array implementation
+# of the routine requires putting the inputs into memory, and retrieving
+# the results from memory.  This routine eliminates the need for this
+# overhead if the data does not already reside in memory.
+# Author: Harsha Jagasia
+# Email:  harsha.jagasia@amd.com
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.data
+.align 64
+.L__real_7fffffffffffffff: .quad 0x07fffffffffffffff	#Sign bit zero
+			.quad 0x07fffffffffffffff
+.L__real_3ff0000000000000: .quad 0x03ff0000000000000	# 1.0
+			.quad 0x03ff0000000000000
+.L__real_v2p__27:		.quad 0x03e40000000000000	# 2p-27
+			.quad 0x03e40000000000000
+.L__real_3fe0000000000000: .quad 0x03fe0000000000000	# 0.5
+			.quad 0x03fe0000000000000
+.L__real_3fc5555555555555: .quad 0x03fc5555555555555	# 0.166666666666
+			.quad 0x03fc5555555555555
+.L__real_3fe45f306dc9c883: .quad 0x03fe45f306dc9c883	# twobypi
+			.quad 0x03fe45f306dc9c883
+.L__real_3ff921fb54400000: .quad 0x03ff921fb54400000	# piby2_1
+			.quad 0x03ff921fb54400000
+.L__real_3dd0b4611a626331: .quad 0x03dd0b4611a626331	# piby2_1tail
+			.quad 0x03dd0b4611a626331
+.L__real_3dd0b4611a600000: .quad 0x03dd0b4611a600000	# piby2_2
+			.quad 0x03dd0b4611a600000
+.L__real_3ba3198a2e037073: .quad 0x03ba3198a2e037073	# piby2_2tail
+			.quad 0x03ba3198a2e037073
+.L__real_fffffffff8000000: .quad 0x0fffffffff8000000	# mask for stripping head and tail
+			.quad 0x0fffffffff8000000
+.L__real_8000000000000000:	.quad 0x08000000000000000	# -0  or signbit
+			.quad 0x08000000000000000
+.L__reald_one_one:		.quad 0x00000000100000001	#
+			.quad 0
+.L__reald_two_two:		.quad 0x00000000200000002	#
+			.quad 0
+.L__reald_one_zero:	.quad 0x00000000100000000	# sin_cos_filter
+			.quad 0
+.L__reald_zero_one:	.quad 0x00000000000000001	#
+			.quad 0
+.L__reald_two_zero:	.quad 0x00000000200000000	#
+			.quad 0
+.L__realq_one_one:		.quad 0x00000000000000001	#
+			.quad 0x00000000000000001		#
+.L__realq_two_two:		.quad 0x00000000000000002	#
+			.quad 0x00000000000000002		#
+.L__real_1_x_mask:		.quad 0x0ffffffffffffffff	#
+			.quad 0x03ff0000000000000		#
+.L__real_zero:		.quad 0x00000000000000000		#
+			.quad 0x00000000000000000		#
+.L__real_one:		.quad 0x00000000000000001		#
+			.quad 0x00000000000000001		#
+
+.Lcosarray:
+	.quad	0x03FA5555555502F31		#  0.0416667			c1
+	.quad	0x03FA5555555502F31
+	.quad	0x0BF56C16BF55699D7		# -0.00138889			c2
+	.quad	0x0BF56C16BF55699D7
+	.quad	0x03EFA015C50A93B49		#  2.48016e-005			c3
+	.quad	0x03EFA015C50A93B49
+	.quad	0x0BE92524743CC46B8		# -2.75573e-007			c4
+	.quad	0x0BE92524743CC46B8
+
+.Lsinarray:
+	.quad	0x0BFC555555545E87D		# -0.166667	   		s1
+	.quad	0x0BFC555555545E87D
+	.quad	0x03F811110DF01232D		# 0.00833333	   		s2
+	.quad	0x03F811110DF01232D
+	.quad	0x0BF2A013A88A37196		# -0.000198413			s3
+	.quad	0x0BF2A013A88A37196
+	.quad	0x03EC6DBE4AD1572D5		# 2.75573e-006			s4
+	.quad	0x03EC6DBE4AD1572D5
+
+.Lsincosarray:
+	.quad	0x0BFC555555545E87D		# -0.166667	   		s1
+	.quad	0x03FA5555555502F31		# 0.0416667		   	c1
+	.quad	0x03F811110DF01232D		# 0.00833333	   		s2
+	.quad	0x0BF56C16BF55699D7
+	.quad	0x0BF2A013A88A37196		# -0.000198413			s3
+	.quad	0x03EFA015C50A93B49
+	.quad	0x03EC6DBE4AD1572D5		# 2.75573e-006			s4
+	.quad	0x0BE92524743CC46B8
+
+.Lcossinarray:
+	.quad	0x03FA5555555502F31		# 0.0416667		   	c1
+	.quad	0x0BFC555555545E87D		# -0.166667	   		s1
+	.quad	0x0BF56C16BF55699D7		#				c2
+	.quad	0x03F811110DF01232D
+	.quad	0x03EFA015C50A93B49		#				c3
+	.quad	0x0BF2A013A88A37196
+	.quad	0x0BE92524743CC46B8		#				c4
+	.quad	0x03EC6DBE4AD1572D5
+
+.align 64
+	.Levensin_oddcos_tbl:
+
+		.quad	.Lsinsin_sinsin_piby4		# 0		*	; Done
+		.quad	.Lsinsin_sincos_piby4		# 1		+	; Done
+		.quad	.Lsinsin_cossin_piby4		# 2			; Done
+		.quad	.Lsinsin_coscos_piby4		# 3		+	; Done
+
+		.quad	.Lsincos_sinsin_piby4		# 4			; Done
+		.quad	.Lsincos_sincos_piby4		# 5		*	; Done
+		.quad	.Lsincos_cossin_piby4		# 6			; Done
+		.quad	.Lsincos_coscos_piby4		# 7			; Done
+
+		.quad	.Lcossin_sinsin_piby4		# 8			; Done
+		.quad	.Lcossin_sincos_piby4		# 9			; TBD
+		.quad	.Lcossin_cossin_piby4		# 10		*	; Done
+		.quad	.Lcossin_coscos_piby4		# 11			; Done
+
+		.quad	.Lcoscos_sinsin_piby4		# 12			; Done
+		.quad	.Lcoscos_sincos_piby4		# 13		+	; Done
+		.quad	.Lcoscos_cossin_piby4		# 14			; Done
+		.quad	.Lcoscos_coscos_piby4		# 15		*	; Done
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+    .text
+    .align 16
+    .p2align 4,,15
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# define local variable storage offsets
+.equ	p_temp,0		# temporary for get/put bits operation
+.equ	p_temp1,0x10		# temporary for get/put bits operation
+
+.equ	save_xmm6,0x20		# temporary for get/put bits operation
+.equ	save_xmm7,0x30		# temporary for get/put bits operation
+.equ	save_xmm8,0x40		# temporary for get/put bits operation
+.equ	save_xmm9,0x50		# temporary for get/put bits operation
+.equ	save_xmm0,0x60		# temporary for get/put bits operation
+.equ	save_xmm11,0x70		# temporary for get/put bits operation
+.equ	save_xmm12,0x80		# temporary for get/put bits operation
+.equ	save_xmm13,0x90		# temporary for get/put bits operation
+.equ	save_xmm14,0x0A0	# temporary for get/put bits operation
+.equ	save_xmm15,0x0B0	# temporary for get/put bits operation
+
+.equ	r,0x0C0			# pointer to r for remainder_piby2
+.equ	rr,0x0D0		# pointer to r for remainder_piby2
+.equ	region,0x0E0		# pointer to r for remainder_piby2
+
+.equ	r1,0x0F0		# pointer to r for remainder_piby2
+.equ	rr1,0x0100		# pointer to r for remainder_piby2
+.equ	region1,0x0110		# pointer to r for remainder_piby2
+
+.equ	p_temp2,0x0120		# temporary for get/put bits operation
+.equ	p_temp3,0x0130		# temporary for get/put bits operation
+
+.equ	p_temp4,0x0140		# temporary for get/put bits operation
+.equ	p_temp5,0x0150		# temporary for get/put bits operation
+
+.equ	p_original,0x0160		# original x
+.equ	p_mask,0x0170		# original x
+.equ	p_sign,0x0180		# original x
+
+.equ	p_original1,0x0190		# original x
+.equ	p_mask1,0x01A0		# original x
+.equ	p_sign1,0x01B0		# original x
+
+.equ	save_r12,0x01C0		# temporary for get/put bits operation
+.equ	save_r13,0x01D0		# temporary for get/put bits operation
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+.globl __vrs4_sinf
+    .type   __vrs4_sinf,@function
+__vrs4_sinf:
+
+	sub		$0x01E8,%rsp
+
+	mov	%r12,save_r12(%rsp)	# save r12
+
+	mov	%r13,save_r13(%rsp)	# save r13
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#STARTMAIN
+
+	movhlps		%xmm0,%xmm8
+	cvtps2pd	%xmm0,%xmm10			# convert input to double.
+	cvtps2pd	%xmm8,%xmm1			# convert input to double.
+
+movdqa	%xmm10,%xmm6
+movdqa	%xmm1,%xmm7
+movapd	.L__real_7fffffffffffffff(%rip),%xmm2
+
+andpd 	%xmm2,%xmm10	#Unsign
+andpd 	%xmm2,%xmm1	#Unsign
+
+movd	%xmm10,%rax				#rax is lower arg
+movhpd	%xmm10, p_temp+8(%rsp)			#
+mov    	p_temp+8(%rsp),%rcx			#rcx = upper arg
+
+movd	%xmm1,%r8				#r8 is lower arg
+movhpd	%xmm1, p_temp1+8(%rsp)			#
+mov    	p_temp1+8(%rsp),%r9			#r9 = upper arg
+
+movdqa	%xmm10,%xmm12
+movdqa	%xmm1,%xmm13
+
+pcmpgtd		%xmm6,%xmm12
+pcmpgtd		%xmm7,%xmm13
+movdqa		%xmm12,%xmm6
+movdqa		%xmm13,%xmm7
+psrldq		$4,%xmm12
+psrldq		$4,%xmm13
+psrldq		$8,%xmm6
+psrldq		$8,%xmm7
+
+mov 	$0x3FE921FB54442D18,%rdx			#piby4	+
+mov	$0x411E848000000000,%r10			#5e5	+
+movapd	.L__real_3fe0000000000000(%rip),%xmm4		#0.5 for later use +
+
+por	%xmm6,%xmm12
+por	%xmm7,%xmm13
+movd	%xmm12,%r12				#Move Sign to gpr **
+movd	%xmm13,%r13				#Move Sign to gpr **
+
+movapd	%xmm10,%xmm2				#x0
+movapd	%xmm1,%xmm3				#x1
+movapd	%xmm10,%xmm6				#x0
+movapd	%xmm1,%xmm7				#x1
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm2 = x, xmm4 =0.5/t, xmm6 =x
+# xmm3 = x, xmm5 =0.5/t, xmm7 =x
+.align 16
+.Leither_or_both_arg_gt_than_piby4:
+	cmp	%r10,%rax
+	jae	.Lfirst_or_next3_arg_gt_5e5
+
+	cmp	%r10,%rcx
+	jae	.Lsecond_or_next2_arg_gt_5e5
+
+	cmp	%r10,%r8
+	jae	.Lthird_or_fourth_arg_gt_5e5
+
+	cmp	%r10,%r9
+	jae	.Lfourth_arg_gt_5e5
+
+
+#      /* Find out what multiple of piby2 */
+#        npi2  = (int)(x * twobypi + 0.5);
+	movapd	.L__real_3fe45f306dc9c883(%rip),%xmm10
+	mulpd	%xmm10,%xmm2						# * twobypi
+	mulpd	%xmm10,%xmm3						# * twobypi
+
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	addpd	%xmm4,%xmm3						# +0.5, npi2
+
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm10		# piby2_1
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm1		# piby2_1
+
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	cvttpd2dq	%xmm3,%xmm5					# convert packed double to packed integers
+
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm9		# piby2_2
+
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+	cvtdq2pd	%xmm5,%xmm3					# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+
+	movd	%xmm4,%r8						# Region
+	movd	%xmm5,%r9						# Region
+
+	mov 	.L__reald_one_zero(%rip),%rdx			#compare value for cossin path
+	mov	%r8,%r10
+	mov	%r9,%r11
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm10						# npi2 * piby2_1;
+       mulpd	%xmm3,%xmm1						# npi2 * piby2_1;
+
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+       mulpd	%xmm3,%xmm9						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm10,%xmm6						# rhead  = x - npi2 * piby2_1;
+       subpd	%xmm1,%xmm7						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm10						# t
+       movapd	%xmm7,%xmm1						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm10						# rhead
+       subpd	%xmm9,%xmm1						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm3		# npi2 * piby2_2tail
+
+       subpd	%xmm10,%xmm6						# t-rhead
+       subpd	%xmm1,%xmm7						# t-rhead
+
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       subpd	%xmm7,%xmm9						# - ((t - rhead) - rtail)
+
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       addpd	%xmm3,%xmm9						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm4  = npi2 (int), xmm10 =rhead, xmm8 =rtail
+# xmm5  = npi2 (int), xmm1 =rhead, xmm9 =rtail
+
+	and	.L__reald_one_one(%rip),%r8		#odd/even region for cos/sin
+	and	.L__reald_one_one(%rip),%r9		#odd/even region for cos/sin
+
+	shr	$1,%r10						#~AB+A~B, A is sign and B is upper bit of region
+	shr	$1,%r11						#~AB+A~B, A is sign and B is upper bit of region
+
+	mov	%r10,%rax
+	mov	%r11,%rcx
+
+	not 	%r12						#ADDED TO CHANGE THE LOGIC
+	not 	%r13						#ADDED TO CHANGE THE LOGIC
+	and	%r12,%r10
+	and	%r13,%r11
+
+	not	%rax
+	not	%rcx
+	not	%r12
+	not	%r13
+	and	%r12,%rax
+	and	%r13,%rcx
+
+	or	%rax,%r10
+	or	%rcx,%r11
+	and	.L__reald_one_one(%rip),%r10				#(~AB+A~B)&1
+	and	.L__reald_one_one(%rip),%r11				#(~AB+A~B)&1
+
+	mov	%r10,%r12
+	mov	%r11,%r13
+
+	and	%rdx,%r12				#mask out the lower sign bit leaving the upper sign bit
+	and	%rdx,%r13				#mask out the lower sign bit leaving the upper sign bit
+
+	shl	$63,%r10				#shift lower sign bit left by 63 bits
+	shl	$63,%r11				#shift lower sign bit left by 63 bits
+	shl	$31,%r12				#shift upper sign bit left by 31 bits
+	shl	$31,%r13				#shift upper sign bit left by 31 bits
+
+	mov 	 %r10,p_sign(%rsp)		#write out lower sign bit
+	mov 	 %r12,p_sign+8(%rsp)		#write out upper sign bit
+	mov 	 %r11,p_sign1(%rsp)		#write out lower sign bit
+	mov 	 %r13,p_sign1+8(%rsp)		#write out upper sign bit
+
+# GET_BITS_DP64(rhead-rtail, uy);			   		; originally only rhead
+# xmm4  = Sign, xmm10 =rhead, xmm8 =rtail
+# xmm5  = Sign, xmm1 =rhead, xmm9 =rtail
+	movapd	%xmm10,%xmm6						# rhead
+	movapd	%xmm1,%xmm7						# rhead
+
+	subpd	%xmm8,%xmm10						# r = rhead - rtail
+	subpd	%xmm9,%xmm1						# r = rhead - rtail
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm4  = Sign, xmm10 = r, xmm6 =rhead, xmm8 =rtail
+# xmm5  = Sign, xmm1 = r, xmm7 =rhead, xmm9 =rtail
+
+	mov	%r8,%rax
+	mov	%r9,%rcx
+
+	movapd	%xmm10,%xmm2				# move r for r2
+	movapd	%xmm1,%xmm3				# move r for r2
+
+	mulpd	%xmm10,%xmm2				# r2
+	mulpd	%xmm1,%xmm3				# r2
+
+	and	.L__reald_zero_one(%rip),%rax
+	and	.L__reald_zero_one(%rip),%rcx
+	shr	$31,%r8
+	shr	$31,%r9
+	or	%r8,%rax
+	or	%r9,%rcx
+	shl	$2,%rcx
+	or	%rcx,%rax
+
+	lea	.Levensin_oddcos_tbl(%rip),%rcx
+	jmp	*(%rcx,%rax,8)				#Jmp table for cos/sin calculation based on even/odd region
+
+
+
+
+
+
+
+
+
+
+
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lfirst_or_next3_arg_gt_5e5:
+# %rcx,,%rax r8, r9
+
+	cmp	%r10,%rcx				#is upper arg >= 5e5
+	jae	.Lboth_arg_gt_5e5
+
+.Llower_arg_gt_5e5:
+# Upper Arg is < 5e5, Lower arg is >= 5e5
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+# Be sure not to use %xmm3,%xmm1 and xmm7
+# Use %xmm8,,%xmm5 xmm0, xmm12
+#	    %xmm11,,%xmm9 xmm13
+
+
+	movlpd	 %xmm10,r(%rsp)		#Save lower fp arg for remainder_piby2 call
+	movhlps	%xmm10,%xmm10			#Needed since we want to work on upper arg
+	movhlps	%xmm2,%xmm2
+	movhlps	%xmm6,%xmm6
+
+# Work on Upper arg
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm4,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm8		# xmm8 = piby2_1
+	cvttsd2si	%xmm2,%ecx				# ecx = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm0		# xmm0 = piby2_2
+	cvtsi2sd	%ecx,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm8					# npi2 * piby2_1
+	subsd	%xmm8,%xmm6					# xmm6 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm12		# xmm12 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm6,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm0					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm0,%xmm6					# xmm6 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm12     					# npi2 * piby2_2tail
+       subsd	%xmm6,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm0					# (rtail-(t-rhead))
+       addsd	%xmm12,%xmm0					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %ecx,region+4(%rsp)			# store upper region
+       movsd	%xmm6,%xmm10
+       subsd	%xmm0,%xmm10					# xmm10 = r=(rhead-rtail)
+       movlpd	 %xmm10,r+8(%rsp)			# store upper r
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#Note that volatiles will be trashed by the call
+#We will construct r, rr, region and sign
+
+# Work on Lower arg
+	mov		$0x07ff0000000000000,%r11			# is lower arg nan/inf
+	mov		%r11,%r10
+	and		%rax,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sinf_lower_naninf
+
+	mov	  %r8,p_temp(%rsp)
+	mov	  %r9,p_temp2(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region(%rsp),%rdx			# lower arg is **NOT** nan/inf
+	lea	 r(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	mov	 r(%rsp),%rdi	#Restore lower fp arg for remainder_piby2 call
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	 p_temp(%rsp),%r8
+	mov	 p_temp2(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+	jmp 	0f
+
+.L__vrs4_sinf_lower_naninf:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rax
+	mov	 %rax,r(%rsp)				# r = x | 0x0008000000000000
+	mov	 %r10d,region(%rsp)			# region =0
+
+.align 16
+0:
+	jmp 	.Lcheck_next2_args
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lboth_arg_gt_5e5:
+#Upper Arg is >= 5e5, Lower arg is >= 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+
+	movhlps %xmm10,%xmm6		#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r11			#is lower arg nan/inf
+	mov		%r11,%r10
+	and		%rax,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sinf_lower_naninf_of_both_gt_5e5
+
+	mov	  %rcx,p_temp(%rsp)			#Save upper arg
+	mov	  %r8,p_temp2(%rsp)
+	mov	  %r9,p_temp4(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	 r(%rsp),%rsi
+
+# added ins- changed input from xmm10 to xmm0
+	movd	 %xmm10,%rdi
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	 p_temp2(%rsp),%r8
+	mov	 p_temp4(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+
+	mov	 p_temp(%rsp),%rcx			#Restore upper arg
+	jmp 	0f
+
+.L__vrs4_sinf_lower_naninf_of_both_gt_5e5:				#lower arg is nan/inf
+#	mov	.LQWORD,%rax PTR p_original[rsp]
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rax
+	mov	 %rax,r(%rsp)				#r = x | 0x0008000000000000
+	mov	 %r10d,region(%rsp)			#region = 0
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r11			#is upper arg nan/inf
+	mov		%r11,%r10
+	and		%rcx,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sinf_upper_naninf_of_both_gt_5e5
+
+
+	mov	  %r8,p_temp2(%rsp)
+	mov	  %r9,p_temp4(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region+4(%rsp),%rdx			#upper arg is **NOT** nan/inf
+	lea	 r+8(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	movd	 %xmm6,%rdi
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	 p_temp2(%rsp),%r8
+	mov	 p_temp4(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+
+	jmp 	0f
+
+.L__vrs4_sinf_upper_naninf_of_both_gt_5e5:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rcx
+	mov	 %rcx,r+8(%rsp)				#r = x | 0x0008000000000000
+	mov	 %r10d,region+4(%rsp)			#region = 0
+
+.align 16
+0:
+	jmp 	.Lcheck_next2_args
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lsecond_or_next2_arg_gt_5e5:
+
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+# Do not use %xmm3,,%xmm1 xmm7
+# Restore xmm4 and %xmm3,,%xmm1 xmm7
+# Can use %xmm0,,%xmm8 xmm12
+#   %xmm9,,%xmm5 xmm11, xmm13
+
+	movhpd	 %xmm10,r+8(%rsp)	#Save upper fp arg for remainder_piby2 call
+
+# Work on Lower arg
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm4,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm8		# xmm3 = piby2_1
+	cvttsd2si	%xmm2,%eax				# ecx = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm0		# xmm1 = piby2_2
+	cvtsi2sd	%eax,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm8					# npi2 * piby2_1
+	subsd	%xmm8,%xmm6					# xmm6 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm12		# xmm7 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm6,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm0					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm0,%xmm6					# xmm6 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm12     				# npi2 * piby2_2tail
+       subsd	%xmm6,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm0					# (rtail-(t-rhead))
+       addsd	%xmm12,%xmm0					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %eax,region(%rsp)			# store upper region
+
+        subsd	%xmm0,%xmm6					# xmm10 = r=(rhead-rtail)
+
+        movlpd	 %xmm6,r(%rsp)				# store upper r
+
+
+#Work on Upper arg
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+	mov		$0x07ff0000000000000,%r11			# is upper arg nan/inf
+	mov		%r11,%r10
+	and		%rcx,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sinf_upper_naninf
+
+	mov	 %r8,p_temp(%rsp)
+	mov	 %r9,p_temp2(%rsp)
+	movapd	 %xmm1,p_temp1(%rsp)
+	movapd	 %xmm3,p_temp3(%rsp)
+	movapd	 %xmm7,p_temp5(%rsp)
+
+	lea	 region+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 r+8(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	mov	 r+8(%rsp),%rdi
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	p_temp(%rsp),%r8
+	mov	p_temp2(%rsp),%r9
+	movapd	p_temp1(%rsp),%xmm1
+	movapd	p_temp3(%rsp),%xmm3
+	movapd	p_temp5(%rsp),%xmm7
+	jmp 	0f
+
+.L__vrs4_sinf_upper_naninf:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rcx
+	mov	 %rcx,r+8(%rsp)				# r = x | 0x0008000000000000
+	mov	 %r10d,region+4(%rsp)			# region =0
+
+.align 16
+0:
+	jmp 	.Lcheck_next2_args
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcheck_next2_args:
+
+	mov	$0x411E848000000000,%r10			#5e5	+
+
+	cmp	%r10,%r8
+	jae	.Lfirst_second_done_third_or_fourth_arg_gt_5e5
+
+	cmp	%r10,%r9
+	jae	.Lfirst_second_done_fourth_arg_gt_5e5
+
+
+
+# Work on next two args, both < 5e5
+# %xmm3,,%xmm1 xmm5 = x, xmm4 = 0.5
+
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4			#Restore 0.5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm3			# * twobypi
+	addpd	%xmm4,%xmm3						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm1		# piby2_1
+	cvttpd2dq	%xmm3,%xmm5					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm9		# piby2_2
+	cvtdq2pd	%xmm5,%xmm3					# and back to double.
+
+###
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movlpd	 %xmm5,region1(%rsp)						# Region
+###
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm3,%xmm1						# npi2 * piby2_1;
+
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm3,%xmm9						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm1,%xmm7						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm7,%xmm1						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm9,%xmm1						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm3		# npi2 * piby2_2tail
+
+       subpd	%xmm1,%xmm7						# t-rhead
+       subpd	%xmm7,%xmm9						# - ((t - rhead) - rtail)
+       addpd	%xmm3,%xmm9						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+#       movapd	%xmm1,%xmm7						; rhead
+       subpd	%xmm9,%xmm1						# r = rhead - rtail
+       movapd	 %xmm1,r1(%rsp)
+
+#       subpd	%xmm1,%xmm7						; rr=rhead-r
+#       subpd	xmm7, xmm9						; rr=(rhead-r) -rtail
+#       movapd	OWORD PTR rr1[rsp], xmm7
+
+	jmp	.L__vrs4_sinf_reconstruct
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lthird_or_fourth_arg_gt_5e5:
+#first two args are < 5e5, third arg >= 5e5, fourth arg >= 5e5 or < 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+# Do not use %xmm3,,%xmm1 xmm7
+# Can use 	%xmm11,,%xmm9 xmm13
+# 	%xmm8,,%xmm5 xmm0, xmm12
+# Restore xmm4
+
+# Work on first two args, both < 5e5
+
+
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# * twobypi
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm10		# piby2_1
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+
+###
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movlpd	 %xmm4,region(%rsp)				# Region
+###
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm10						# npi2 * piby2_1;
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm10,%xmm6						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm10						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm10						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+
+       subpd	%xmm10,%xmm6						# t-rhead
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+#       movapd	%xmm10,%xmm6						; rhead
+       subpd	%xmm8,%xmm10						# r = rhead - rtail
+       movapd	 %xmm10,r(%rsp)
+
+#       subpd	%xmm10,%xmm6						; rr=rhead-r
+#       subpd	xmm6, xmm8						; rr=(rhead-r) -rtail
+#       movapd	OWORD PTR rr[rsp], xmm6
+
+
+# Work on next two args, third arg >= 5e5, fourth arg >= 5e5 or < 5e5
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lfirst_second_done_third_or_fourth_arg_gt_5e5:
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+
+
+	mov	$0x411E848000000000,%r10			#5e5	+
+	cmp	%r10,%r9
+	jae	.Lboth_arg_gt_5e5_higher
+
+
+# Upper Arg is <5e5, Lower arg is >= 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+	movlpd	 %xmm1,r1(%rsp)		#Save lower fp arg for remainder_piby2 call
+	movhlps	%xmm1,%xmm1			#Needed since we want to work on upper arg
+	movhlps	%xmm3,%xmm3
+	movhlps	%xmm7,%xmm7
+
+
+# Work on Upper arg
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4		# Restore 0.5
+
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm3		# x*twobypi
+	addsd	%xmm4,%xmm3					# xmm3 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm2		# xmm2 = piby2_1
+	cvttsd2si	%xmm3,%r9d				# r9d = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm10		# xmm10 = piby2_2
+	cvtsi2sd	%r9d,%xmm3				# xmm3 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm3,%xmm2					# npi2 * piby2_1
+	subsd	%xmm2,%xmm7					# xmm7 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm7,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm3,%xmm10					# xmm10 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm10,%xmm7					# xmm7 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm3,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm7,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm10					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm10					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %r9d,region1+4(%rsp)			# store upper region
+
+       subsd	%xmm10,%xmm7					# xmm1 = r=(rhead-rtail)
+
+       movlpd	 %xmm7,r1+8(%rsp)			# store upper r
+
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+
+# Work on Lower arg
+	mov		$0x07ff0000000000000,%r11			# is lower arg nan/inf
+	mov		%r11,%r10
+	and		%r8,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sinf_lower_naninf_higher
+
+	lea	 region1(%rsp),%rdx			# lower arg is **NOT** nan/inf
+	lea	 r1(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+  	mov	 r1(%rsp),%rdi
+
+	call	 __remainder_piby2d2f@PLT
+
+	jmp 	0f
+
+.L__vrs4_sinf_lower_naninf_higher:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r8
+	mov	 %r8,r1(%rsp)				# r = x | 0x0008000000000000
+	mov	 %r10d,region1(%rsp)			# region =0
+
+.align 16
+0:
+	jmp 	.L__vrs4_sinf_reconstruct
+
+
+
+
+
+
+
+.align 16
+.Lboth_arg_gt_5e5_higher:
+# Upper Arg is >= 5e5, Lower arg is >= 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+
+	movhlps %xmm1,%xmm7		#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r11			#is lower arg nan/inf
+	mov		%r11,%r10
+	and		%r8,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sinf_lower_naninf_of_both_gt_5e5_higher
+
+	mov	  %r9,p_temp1(%rsp)			#Save upper arg
+	lea	 region1(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	 r1(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	movd	 %xmm1,%rdi
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	 p_temp1(%rsp),%r9			#Restore upper arg
+
+	jmp 	0f
+
+.L__vrs4_sinf_lower_naninf_of_both_gt_5e5_higher:				#lower arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r8
+	mov	 %r8,r1(%rsp)				#r = x | 0x0008000000000000
+	mov	 %r10d,region1(%rsp)			#region = 0
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r11			#is upper arg nan/inf
+	mov		%r11,%r10
+	and		%r9,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sinf_upper_naninf_of_both_gt_5e5_higher
+
+	lea	 region1+4(%rsp),%rdx			#upper arg is **NOT** nan/inf
+	lea	 r1+8(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	movd	 %xmm7,%rdi
+
+	call	 __remainder_piby2d2f@PLT
+
+	jmp 	0f
+
+.L__vrs4_sinf_upper_naninf_of_both_gt_5e5_higher:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r9
+	mov	 %r9,r1+8(%rsp)				#r = x | 0x0008000000000000
+	mov	 %r10d,region1+4(%rsp)			#region = 0
+
+.align 16
+0:
+	jmp 	.L__vrs4_sinf_reconstruct
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lfourth_arg_gt_5e5:
+#first two args are < 5e5, third arg < 5e5, fourth arg >= 5e5
+#%rcx,,%rax r8, r9
+#%xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+
+# Work on first two args, both < 5e5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# * twobypi
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm10		# piby2_1
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+
+###
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movlpd	 %xmm4,region(%rsp)				# Region
+###
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm10						# npi2 * piby2_1;
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm10,%xmm6						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm10						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm10						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+
+       subpd	%xmm10,%xmm6						# t-rhead
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+#       movapd	%xmm10,%xmm6						; rhead
+       subpd	%xmm8,%xmm10						# r = rhead - rtail
+       movapd	 %xmm10,r(%rsp)
+
+#       subpd	%xmm10,%xmm6						; rr=rhead-r
+#       subpd	xmm6, xmm8						; rr=(rhead-r) -rtail
+#       movapd	OWORD PTR rr[rsp], xmm6
+
+
+# Work on next two args, third arg < 5e5, fourth arg >= 5e5
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lfirst_second_done_fourth_arg_gt_5e5:
+
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+	movhpd	 %xmm1,r1+8(%rsp)	#Save upper fp arg for remainder_piby2 call
+
+# Work on Lower arg
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4		# Restore 0.5
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm3		# x*twobypi
+	addsd	%xmm4,%xmm3					# xmm3 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm2		# xmm2 = piby2_1
+	cvttsd2si	%xmm3,%r8d				# r8d = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm10		# xmm10 = piby2_2
+	cvtsi2sd	%r8d,%xmm3				# xmm3 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm3,%xmm2					# npi2 * piby2_1
+	subsd	%xmm2,%xmm7					# xmm7 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm7,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm3,%xmm10					# xmm10 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm10,%xmm7					# xmm7 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm3,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm7,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm10					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm10					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %r8d,region1(%rsp)			# store lower region
+
+#       movsd	%xmm7,%xmm1
+#       subsd	xmm1, xmm10					; xmm10 = r=(rhead-rtail)
+#       subsd	%xmm1,%xmm7					; rr=rhead-r
+#       subsd	xmm7, xmm10					; xmm6 = rr=((rhead-r) -rtail)
+
+        subsd	%xmm10,%xmm7					# xmm10 = r=(rhead-rtail)
+
+#       movlpd	QWORD PTR r1[rsp], xmm1				; store upper r
+#       movlpd	QWORD PTR rr1[rsp], xmm7			; store upper rr
+
+        movlpd	 %xmm7,r1(%rsp)				# store upper r
+
+#Work on Upper arg
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+	mov		$0x07ff0000000000000,%r11			# is upper arg nan/inf
+	mov		%r11,%r10
+	and		%r9,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sinf_upper_naninf_higher
+
+	lea	 region1+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 r1+8(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	mov	 r1+8(%rsp),%rdi
+
+	call	 __remainder_piby2d2f@PLT
+
+	jmp 	0f
+
+.L__vrs4_sinf_upper_naninf_higher:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r9
+	mov	 %r9,r1+8(%rsp)				# r = x | 0x0008000000000000
+	mov	 %r10d,region1+4(%rsp)			# region =0
+
+.align 16
+0:
+	jmp	.L__vrs4_sinf_reconstruct
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrs4_sinf_reconstruct:
+#Results
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	r(%rsp),%xmm10
+	movapd	r1(%rsp),%xmm1
+
+	mov	region(%rsp),%r8
+	mov	region1(%rsp),%r9
+	mov 	.L__reald_one_zero(%rip),%rdx		#compare value for cossin path
+
+	mov 	%r8,%r10
+	mov 	%r9,%r11
+
+	and	.L__reald_one_one(%rip),%r8		#odd/even region for cos/sin
+	and	.L__reald_one_one(%rip),%r9		#odd/even region for cos/sin
+
+	shr	$1,%r10						#~AB+A~B, A is sign and B is upper bit of region
+	shr	$1,%r11						#~AB+A~B, A is sign and B is upper bit of region
+
+	mov	%r10,%rax
+	mov	%r11,%rcx
+
+	not 	%r12						#ADDED TO CHANGE THE LOGIC
+	not 	%r13						#ADDED TO CHANGE THE LOGIC
+	and	%r12,%r10
+	and	%r13,%r11
+
+	not	%rax
+	not	%rcx
+	not	%r12
+	not	%r13
+	and	%r12,%rax
+	and	%r13,%rcx
+
+	or	%rax,%r10
+	or	%rcx,%r11
+	and	.L__reald_one_one(%rip),%r10				#(~AB+A~B)&1
+	and	.L__reald_one_one(%rip),%r11				#(~AB+A~B)&1
+
+	mov	%r10,%r12
+	mov	%r11,%r13
+
+	and	%rdx,%r12				#mask out the lower sign bit leaving the upper sign bit
+	and	%rdx,%r13				#mask out the lower sign bit leaving the upper sign bit
+
+	shl	$63,%r10				#shift lower sign bit left by 63 bits
+	shl	$63,%r11				#shift lower sign bit left by 63 bits
+	shl	$31,%r12				#shift upper sign bit left by 31 bits
+	shl	$31,%r13				#shift upper sign bit left by 31 bits
+
+	mov 	 %r10,p_sign(%rsp)		#write out lower sign bit
+	mov 	 %r12,p_sign+8(%rsp)		#write out upper sign bit
+	mov 	 %r11,p_sign1(%rsp)		#write out lower sign bit
+	mov 	 %r13,p_sign1+8(%rsp)		#write out upper sign bit
+
+	mov	%r8,%rax
+	mov	%r9,%rcx
+
+	movapd	%xmm10,%xmm2
+	movapd	%xmm1,%xmm3
+
+	mulpd	%xmm10,%xmm2				# r2
+	mulpd	%xmm1,%xmm3				# r2
+
+	and	.L__reald_zero_one(%rip),%rax
+	and	.L__reald_zero_one(%rip),%rcx
+	shr	$31,%r8
+	shr	$31,%r9
+	or	%r8,%rax
+	or	%r9,%rcx
+	shl	$2,%rcx
+	or	%rcx,%rax
+
+
+	lea	.Levensin_oddcos_tbl(%rip),%rcx
+	jmp	*(%rcx,%rax,8)				#Jmp table for cos/sin calculation based on even/odd region
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrs4_sinf_cleanup:
+
+	movapd	  p_sign(%rsp),%xmm10
+	movapd	  p_sign1(%rsp),%xmm1
+
+	xorpd	%xmm4,%xmm10			# (+) Sign
+	xorpd	%xmm5,%xmm1			# (+) Sign
+
+	cvtpd2ps %xmm10,%xmm0
+	cvtpd2ps %xmm1,%xmm11
+	movlhps	 %xmm11,%xmm0
+
+	mov	save_r12(%rsp),%r12	# restore r12
+	mov	save_r13(%rsp),%r13	# restore r13
+
+	add	$0x01E8,%rsp
+	ret
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;JUMP TABLE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcoscos_coscos_piby4:
+	movapd	%xmm2,%xmm0					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lcosarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lcosarray+0x30(%rip),%xmm5			# c4
+
+	movapd	.Lcosarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lcosarray+0x10(%rip),%xmm9			# c2
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm0	# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11	# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm0		# -t=r-1.0	;trash r
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0	;trash r
+
+	mulpd	%xmm2,%xmm2					# x4
+	mulpd	%xmm3,%xmm3					# x4
+
+	addpd	.Lcosarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lcosarray+0x20(%rip),%xmm5			# c3+x2c4
+
+	addpd	.Lcosarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lcosarray(%rip),%xmm9			# c1+x2c2
+
+	mulpd	%xmm2,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm3,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x4 * zc
+
+	subpd   %xmm0,%xmm4					# + t
+	subpd   %xmm11,%xmm5					# + t
+
+	jmp 	.L__vrs4_sinf_cleanup
+
+.align 16
+.Lcossin_cossin_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movdqa	.Lsincosarray+0x30(%rip),%xmm4		# s4
+	movdqa	.Lsincosarray+0x30(%rip),%xmm5		# s4
+	movapd	.Lsincosarray+0x10(%rip),%xmm8		# s2
+	movapd	.Lsincosarray+0x10(%rip),%xmm9		# s2
+
+	movapd	%xmm2,%xmm0				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+
+	mulpd	%xmm2,%xmm4				# x2s4
+	mulpd	%xmm3,%xmm5				# x2s4
+	mulpd	%xmm2,%xmm8				# x2s2
+	mulpd	%xmm3,%xmm9				# x2s2
+
+	mulpd	%xmm2,%xmm0				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lsincosarray+0x20(%rip),%xmm4		# s4+x2s3
+	addpd	.Lsincosarray+0x20(%rip),%xmm5		# s4+x2s3
+	addpd	.Lsincosarray(%rip),%xmm8		# s2+x2s1
+	addpd	.Lsincosarray(%rip),%xmm9		# s2+x2s1
+
+	mulpd	%xmm0,%xmm4				# x4(s3+x2s4)
+	mulpd	%xmm11,%xmm5				# x4(s3+x2s4)
+
+	movhlps	%xmm0,%xmm0				# move high x4 for cos term
+	movhlps	%xmm11,%xmm11				# move high x4 for cos term
+
+	movsd	%xmm2,%xmm6				# move low x2 for x3 for sin term
+	movsd	%xmm3,%xmm7				# move low x2 for x3 for sin term
+	mulsd	%xmm10,%xmm6				# get low x3 for sin term
+	mulsd	%xmm1,%xmm7				# get low x3 for sin term
+
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for sin and cos terms
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for sin and cos terms
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm2,%xmm12				# move high r for cos
+	movhlps	%xmm3,%xmm13				# move high r for cos
+
+	movhlps	%xmm4,%xmm8				# xmm4 = sin , xmm8 = cos
+	movhlps	%xmm5,%xmm9				# xmm4 = sin , xmm8 = cos
+
+	mulsd	%xmm6,%xmm4				# sin *x3
+	mulsd	%xmm7,%xmm5				# sin *x3
+
+	mulsd	%xmm0,%xmm8				# cos *x4
+	mulsd	%xmm11,%xmm9				# cos *x4
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12 	#-t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13 	#-t=r-1.0
+
+	addsd	%xmm10,%xmm4				# sin + x
+	addsd	%xmm1,%xmm5				# sin + x
+	subsd   %xmm12,%xmm8				# cos+t
+	subsd   %xmm13,%xmm9				# cos+t
+
+	movlhps	%xmm8,%xmm4
+	movlhps	%xmm9,%xmm5
+
+	jmp 	.L__vrs4_sinf_cleanup
+.align 16
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lsincos_cossin_piby4:
+
+	movapd	.Lsincosarray+0x30(%rip),%xmm4		# s4
+	movapd	.Lcossinarray+0x30(%rip),%xmm5		# s4
+	movdqa	.Lsincosarray+0x10(%rip),%xmm8		# s2
+	movdqa	.Lcossinarray+0x10(%rip),%xmm9		# s2
+
+	movapd	%xmm2,%xmm0				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+	movapd	%xmm3,%xmm7				# sincos term upper x2 for x3
+
+	mulpd	%xmm2,%xmm4				# x2s4
+	mulpd	%xmm3,%xmm5				# x2s4
+	mulpd	%xmm2,%xmm8				# x2s2
+	mulpd	%xmm3,%xmm9				# x2s2
+
+	mulpd	%xmm2,%xmm0				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lsincosarray+0x20(%rip),%xmm4		# s3+x2s4
+	addpd	.Lcossinarray+0x20(%rip),%xmm5		# s3+x2s4
+	addpd	.Lsincosarray(%rip),%xmm8		# s1+x2s2
+	addpd	.Lcossinarray(%rip),%xmm9		# s1+x2s2
+
+	mulpd	%xmm0,%xmm4				# x4(s3+x2s4)
+	mulpd	%xmm11,%xmm5				# x4(s3+x2s4)
+
+	movhlps	%xmm0,%xmm0				# move high x4 for cos term
+
+	movsd	%xmm2,%xmm6				# move low x2 for x3 for sin term  (cossin)
+	mulpd	%xmm1,%xmm7
+
+	mulsd	%xmm10,%xmm6				# get low x3 for sin term (cossin)
+	movhlps	%xmm7,%xmm7				# get high x3 for sin term (sincos)
+
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for cos term
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for cos term
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+
+	movhlps	%xmm2,%xmm12				# move high r for cos (cossin)
+
+
+	movhlps	%xmm4,%xmm8				# xmm8 = cos , xmm4 = sin	(cossin)
+	movhlps	%xmm5,%xmm9				# xmm9 = sin , xmm5 = cos	(sincos)
+
+	mulsd	%xmm6,%xmm4				# sin *x3
+	mulsd	%xmm11,%xmm5				# cos *x4
+	mulsd	%xmm0,%xmm8				# cos *x4
+	mulsd	%xmm7,%xmm9				# sin *x3
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12 	#-t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm3 	# -t=r-1.0
+
+	movhlps	%xmm1,%xmm11				# move high x for x for sin term    (sincos)
+
+	addsd	%xmm10,%xmm4				# sin + x	+
+	addsd	%xmm11,%xmm9				# sin + x	+
+
+	subsd   %xmm12,%xmm8				# cos+t
+	subsd   %xmm3,%xmm5				# cos+t
+
+	movlhps	%xmm8,%xmm4				# cossin
+	movlhps	%xmm9,%xmm5				# sincos
+
+	jmp	.L__vrs4_sinf_cleanup
+
+.align 16
+.Lsincos_sincos_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	.Lcossinarray+0x30(%rip),%xmm4		# s4
+	movapd	.Lcossinarray+0x30(%rip),%xmm5		# s4
+	movdqa	.Lcossinarray+0x10(%rip),%xmm8		# s2
+	movdqa	.Lcossinarray+0x10(%rip),%xmm9		# s2
+
+	movapd	%xmm2,%xmm0				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+	movapd	%xmm2,%xmm6				# move x2 for x4
+	movapd	%xmm3,%xmm7				# move x2 for x4
+
+	mulpd	%xmm2,%xmm4				# x2s6
+	mulpd	%xmm3,%xmm5				# x2s6
+	mulpd	%xmm2,%xmm8				# x2s3
+	mulpd	%xmm3,%xmm9				# x2s3
+
+	mulpd	%xmm2,%xmm0				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lcossinarray+0x20(%rip),%xmm4		# s4+x2s3
+	addpd	.Lcossinarray+0x20(%rip),%xmm5		# s4+x2s3
+	addpd	.Lcossinarray(%rip),%xmm8		# s2+x2s1
+	addpd	.Lcossinarray(%rip),%xmm9		# s2+x2s1
+
+	mulpd	%xmm0,%xmm4				# x4(s4+x2s3)
+	mulpd	%xmm11,%xmm5				# x4(s4+x2s3)
+
+	mulpd	%xmm10,%xmm6				# get low x3 for sin term
+	mulpd	%xmm1,%xmm7				# get low x3 for sin term
+	movhlps	%xmm6,%xmm6				# move low x2 for x3 for sin term
+	movhlps	%xmm7,%xmm7				# move low x2 for x3 for sin term
+
+	mulsd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for cos terms
+	mulsd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for cos terms
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm4,%xmm12				# xmm8 = sin , xmm4 = cos
+	movhlps	%xmm5,%xmm13				# xmm9 = sin , xmm5 = cos
+
+	mulsd	%xmm6,%xmm12				# sin *x3
+	mulsd	%xmm7,%xmm13				# sin *x3
+	mulsd	%xmm0,%xmm4				# cos *x4
+	mulsd	%xmm11,%xmm5				# cos *x4
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm2 	#-t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm3 	#-t=r-1.0
+
+	movhlps	%xmm10,%xmm0				# move high x for x for sin term
+	movhlps	%xmm1,%xmm11				# move high x for x for sin term
+							# Reverse 10 and 0
+
+	addsd	%xmm0,%xmm12				# sin + x
+	addsd	%xmm11,%xmm13				# sin + x
+
+	subsd   %xmm2,%xmm4				# cos+t
+	subsd   %xmm3,%xmm5				# cos+t
+
+	movlhps	%xmm12,%xmm4
+	movlhps	%xmm13,%xmm5
+	jmp 	.L__vrs4_sinf_cleanup
+
+.align 16
+.Lcossin_sincos_piby4:
+
+	movapd	.Lcossinarray+0x30(%rip),%xmm4		# s4
+	movapd	.Lsincosarray+0x30(%rip),%xmm5		# s4
+	movdqa	.Lcossinarray+0x10(%rip),%xmm8		# s2
+	movdqa	.Lsincosarray+0x10(%rip),%xmm9		# s2
+
+	movapd	%xmm2,%xmm0				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+	movapd	%xmm2,%xmm7				# upper x2 for x3 for sin term (sincos)
+
+	mulpd	%xmm2,%xmm4				# x2s4
+	mulpd	%xmm3,%xmm5				# x2s4
+	mulpd	%xmm2,%xmm8				# x2s2
+	mulpd	%xmm3,%xmm9				# x2s2
+
+	mulpd	%xmm2,%xmm0				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lcossinarray+0x20(%rip),%xmm4		# s3+x2s4
+	addpd	.Lsincosarray+0x20(%rip),%xmm5		# s3+x2s4
+	addpd	.Lcossinarray(%rip),%xmm8		# s1+x2s2
+	addpd	.Lsincosarray(%rip),%xmm9		# s1+x2s2
+
+	mulpd	%xmm0,%xmm4				# x4(s3+x2s4)
+	mulpd	%xmm11,%xmm5				# x4(s3+x2s4)
+
+	movhlps	%xmm11,%xmm11				# move high x4 for cos term
+
+	movsd	%xmm3,%xmm6				# move low x2 for x3 for sin term  (cossin)
+	mulpd	%xmm10,%xmm7
+
+	mulsd	%xmm1,%xmm6				# get low x3 for sin term (cossin)
+	movhlps	%xmm7,%xmm7				# get high x3 for sin term (sincos)
+
+	mulsd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for cos term
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for cos term
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+
+	movhlps	%xmm3,%xmm12				# move high r for cos (cossin)
+
+
+	movhlps	%xmm4,%xmm8				# xmm8 = sin , xmm4 = cos	(sincos)
+	movhlps	%xmm5,%xmm9				# xmm9 = cos , xmm5 = sin	(cossin)
+
+	mulsd	%xmm0,%xmm4				# cos *x4
+	mulsd	%xmm6,%xmm5				# sin *x3
+	mulsd	%xmm7,%xmm8				# sin *x3
+	mulsd	%xmm11,%xmm9				# cos *x4
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm2 	# -t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12 	# -t=r-1.0
+
+	movhlps	%xmm10,%xmm11				# move high x for x for sin term    (sincos)
+
+	subsd	%xmm2,%xmm4				# cos-(-t)
+	subsd	%xmm12,%xmm9				# cos-(-t)
+
+	addsd   %xmm11,%xmm8				# sin + x
+	addsd   %xmm1,%xmm5				# sin + x
+
+	movlhps	%xmm8,%xmm4				# cossin
+	movlhps	%xmm9,%xmm5				# sincos
+
+	jmp	.L__vrs4_sinf_cleanup
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcoscos_sinsin_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr: 	SIN
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr:	COS
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	%xmm2,%xmm0					# x2	; SIN
+	movapd	%xmm3,%xmm11					# x2	; COS
+	movapd	%xmm3,%xmm1					# copy of x2 for x4
+
+	movdqa	.Lsinarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lcosarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lsinarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lcosarray+0x10(%rip),%xmm9			# c2
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	mulpd	%xmm2,%xmm0					# x4
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11		# -t=r-1.0
+	mulpd	%xmm3,%xmm1					# x4
+
+	addpd	.Lsinarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lcosarray+0x20(%rip),%xmm5			# c3+x2c4
+	addpd	.Lsinarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lcosarray(%rip),%xmm9			# c1+x2c2
+
+	mulpd	%xmm10,%xmm2					# x3
+
+	mulpd	%xmm0,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm1,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm1,%xmm5					# x4 * zc
+
+	addpd	%xmm10,%xmm4					# +x
+	subpd   %xmm11,%xmm5					# +t
+
+	jmp 	.L__vrs4_sinf_cleanup
+
+.align 16
+.Lsinsin_coscos_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr: 	COS
+# p_sign1  = Sign, xmm1  = r, xmm3 = %xmm7,%r2 =rr:	SIN
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	%xmm2,%xmm0					# x2	; COS
+	movapd	%xmm3,%xmm11					# x2	; SIN
+	movapd	%xmm2,%xmm10					# copy of x2 for x4
+
+	movdqa	.Lcosarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lsinarray+0x30(%rip),%xmm5			# s4
+	movapd	.Lcosarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lsinarray+0x10(%rip),%xmm9			# s2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# s4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# s2*x2
+
+	mulpd	%xmm2,%xmm10					# x4
+	mulpd	%xmm3,%xmm11					# x4
+
+	addpd	.Lcosarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lsinarray+0x20(%rip),%xmm5			# s3+x2c4
+	addpd	.Lcosarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lsinarray(%rip),%xmm9			# s1+x2c2
+
+	mulpd	%xmm1,%xmm3					# x3
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+
+	mulpd	%xmm10,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm11,%xmm5					# x4(s3+x2s4)
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm0		# -t=r-1.0
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zs
+
+	mulpd	%xmm10,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x3 * zc
+
+	subpd	%xmm0,%xmm4					# +t
+	addpd   %xmm1,%xmm5					# +x
+
+	jmp 	.L__vrs4_sinf_cleanup
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcoscos_cossin_piby4:				#Derive from cossin_coscos
+	movhlps	%xmm2,%xmm0					# x2 for 0.5x2 for upper cos
+	movsd	%xmm2,%xmm6					# lower x2 for x3 for lower sin
+	movapd	%xmm3,%xmm11					# x2 for 0.5x2
+	movapd	%xmm2,%xmm12					# x2 for x4
+	movapd	%xmm3,%xmm13					# x2 for x4
+
+	movsd	.L__real_3ff0000000000000(%rip),%xmm7
+
+	movdqa	.Lsincosarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lcosarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lsincosarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lcosarray+0x10(%rip),%xmm9			# c2
+
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0	# 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11	# 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	subsd	%xmm0,%xmm7					#  t=1.0-r  for cos
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lsincosarray+0x20(%rip),%xmm4			# c4+x2c3
+	addpd	.Lcosarray+0x20(%rip),%xmm5			# c4+x2c3
+	addpd	.Lsincosarray(%rip),%xmm8			# c2+x2c1
+	addpd	.Lcosarray(%rip),%xmm9			# c2+x2c1
+
+
+	movapd	%xmm12,%xmm2					# upper=x4
+	movsd	%xmm6,%xmm2					# lower=x2
+	mulsd	%xmm10,%xmm2					# lower=x2*x
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm2,%xmm4					# upper= x4 * zc
+								# lower=x3 * zs
+	mulpd	%xmm13,%xmm5					# x4 * zc
+
+
+	movlhps	%xmm7,%xmm10					#
+	addpd	%xmm10,%xmm4					# +x for lower sin, +t for upper cos
+	subpd   %xmm11,%xmm5					# -(-t)
+
+	jmp 	.L__vrs4_sinf_cleanup
+.align 16
+.Lcoscos_sincos_piby4:				#Derive from cossin_coscos
+	movsd	%xmm2,%xmm0					# x2 for 0.5x2 for lower cos
+	movapd	%xmm3,%xmm11					# x2 for 0.5x2
+	movapd	%xmm2,%xmm12					# x2 for x4
+	movapd	%xmm3,%xmm13					# x2 for x4
+	movsd	.L__real_3ff0000000000000(%rip),%xmm7
+
+	movdqa	.Lcossinarray+0x30(%rip),%xmm4			# cs4
+	movdqa	.Lcosarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lcossinarray+0x10(%rip),%xmm8			# cs2
+	movapd	.Lcosarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	subsd	%xmm0,%xmm7					# t=1.0-r  for cos
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11		# -t=r-1.0
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lcossinarray+0x20(%rip),%xmm4			# c4+x2c3
+	addpd	.Lcosarray+0x20(%rip),%xmm5			# c4+x2c3
+	addpd	.Lcossinarray(%rip),%xmm8			# c2+x2c1
+	addpd	.Lcosarray(%rip),%xmm9				# c2+x2c1
+
+	mulpd	%xmm10,%xmm2					# upper=x3 for sin
+	mulsd	%xmm10,%xmm2					# lower=x4 for cos
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm2,%xmm4					# lower= x4 * zc
+								# upper= x3 * zs
+	mulpd	%xmm13,%xmm5					# x4 * zc
+
+
+	movsd	%xmm7,%xmm10
+	addpd	%xmm10,%xmm4					# +x for upper sin, +t for lower cos
+	subpd   %xmm11,%xmm5					# -(-t)
+
+	jmp 	.L__vrs4_sinf_cleanup
+.align 16
+.Lcossin_coscos_piby4:
+	movhlps	%xmm3,%xmm0					# x2 for 0.5x2 for upper cos
+	movapd	%xmm2,%xmm11					# x2 for 0.5x2
+	movapd	%xmm2,%xmm12					# x2 for x4
+	movapd	%xmm3,%xmm13					# x2 for x4
+	movsd	%xmm3,%xmm6					# lower x2 for x3 for sin
+	movsd	.L__real_3ff0000000000000(%rip),%xmm7
+
+	movdqa	.Lcosarray+0x30(%rip),%xmm4			# cs4
+	movdqa	.Lsincosarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lcosarray+0x10(%rip),%xmm8			# cs2
+	movapd	.Lsincosarray+0x10(%rip),%xmm9			# c2
+
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	subsd	%xmm0,%xmm7					# t=1.0-r  for cos
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11		# -t=r-1.0
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lcosarray+0x20(%rip),%xmm4			# c4+x2c3
+	addpd	.Lsincosarray+0x20(%rip),%xmm5			# c4+x2c3
+	addpd	.Lcosarray(%rip),%xmm8			# c2+x2c1
+	addpd	.Lsincosarray(%rip),%xmm9			# c2+x2c1
+
+	movapd	%xmm13,%xmm3					# upper=x4
+	movsd	%xmm6,%xmm3					# lower x2
+	mulsd	%xmm1,%xmm3					# lower x2*x
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm12,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# upper= x4 * zc
+								# lower=x3 * zs
+
+	movlhps	%xmm7,%xmm1
+	addpd	%xmm1,%xmm5					# +x for lower sin, +t for upper cos
+	subpd   %xmm11,%xmm4					# -(-t)
+
+	jmp 	.L__vrs4_sinf_cleanup
+
+.align 16
+.Lcossin_sinsin_piby4:		# Derived from sincos_coscos
+
+	movhlps	%xmm3,%xmm0					# x2
+	movapd	%xmm3,%xmm7
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+	movsd	.L__real_3ff0000000000000(%rip),%xmm11
+
+	movdqa	.Lsinarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lsincosarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lsinarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lsincosarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	mulpd	%xmm2,%xmm12					# x4
+	subsd	%xmm0,%xmm11					# t=1.0-r for cos
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lsinarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lsincosarray+0x20(%rip),%xmm5			# c3+x2c4
+	addpd	.Lsinarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lsincosarray(%rip),%xmm9			# c1+x2c2
+
+	mulpd	%xmm10,%xmm2					# x3
+	movapd	%xmm13,%xmm3					# upper x4 for cos
+	movsd	%xmm7,%xmm3					# lower x2 for sin
+	mulsd	%xmm1,%xmm3					# lower x3=x2*x for sin
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	movlhps	%xmm11,%xmm1					# t for upper cos and x for lower sin
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zs
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm3,%xmm5					# upper=x4 * zc
+								# lower=x3 * zs
+
+	addpd   %xmm10,%xmm4					# +x
+	addpd	%xmm1,%xmm5					# +t upper, +x lower
+
+
+	jmp 	.L__vrs4_sinf_cleanup
+.align 16
+.Lsincos_coscos_piby4:
+	movsd	%xmm3,%xmm0					# x2 for 0.5x2 for lower cos
+	movapd	%xmm2,%xmm11					# x2 for 0.5x2
+	movapd	%xmm2,%xmm12					# x2 for x4
+	movapd	%xmm3,%xmm13					# x2 for x4
+	movsd	.L__real_3ff0000000000000(%rip),%xmm7
+
+	movdqa	.Lcosarray+0x30(%rip),%xmm4			# cs4
+	movdqa	.Lcossinarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lcosarray+0x10(%rip),%xmm8			# cs2
+	movapd	.Lcossinarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0	# 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11	# 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	subsd	%xmm0,%xmm7					# t=1.0-r  for cos
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lcosarray+0x20(%rip),%xmm4			# c4+x2c3
+	addpd	.Lcossinarray+0x20(%rip),%xmm5			# c4+x2c3
+	addpd	.Lcosarray(%rip),%xmm8			# c2+x2c1
+	addpd	.Lcossinarray(%rip),%xmm9			# c2+x2c1
+
+	mulpd	%xmm1,%xmm3					# upper=x3 for sin
+	mulsd	%xmm1,%xmm3					# lower=x4 for cos
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm12,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# lower= x4 * zc
+								# upper= x3 * zs
+
+	movsd	%xmm7,%xmm1
+	subpd   %xmm11,%xmm4					# -(-t)
+	addpd	%xmm1,%xmm5					# +x for upper sin, +t for lower cos
+
+
+	jmp 	.L__vrs4_sinf_cleanup
+
+.align 16
+.Lsincos_sinsin_piby4:		# Derived from sincos_coscos
+
+	movsd	%xmm3,%xmm0					# x2
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+	movsd	.L__real_3ff0000000000000(%rip),%xmm11
+
+	movdqa	.Lsinarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lcossinarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lsinarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lcossinarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	mulpd	%xmm2,%xmm12					# x4
+	subsd	%xmm0,%xmm11					# t=1.0-r for cos
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lsinarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lcossinarray+0x20(%rip),%xmm5			# c3+x2c4
+	addpd	.Lsinarray(%rip),%xmm8				# c1+x2c2
+	addpd	.Lcossinarray(%rip),%xmm9			# c1+x2c2
+
+	mulpd	%xmm10,%xmm2					# x3
+	mulpd	%xmm1,%xmm3					# upper x3 for sin
+	mulsd	%xmm1,%xmm3					# lower x4 for cos
+
+	movhlps	%xmm1,%xmm6
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	movlhps	%xmm6,%xmm11					# upper =t ; lower =x
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zszc
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm3,%xmm5					# lower=x4 * zc
+								# upper=x3 * zs
+
+	addpd   %xmm10,%xmm4					# +x
+	addpd	%xmm11,%xmm5					# +t lower, +x upper
+
+	jmp 	.L__vrs4_sinf_cleanup
+
+.align 16
+.Lsinsin_cossin_piby4:		# Derived from sincos_coscos
+
+	movhlps	%xmm2,%xmm0					# x2
+	movapd	%xmm2,%xmm7
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+	movsd	.L__real_3ff0000000000000(%rip),%xmm11
+
+	movdqa	.Lsincosarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lsinarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lsincosarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lsinarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	mulpd	%xmm2,%xmm12					# x4
+	subsd	%xmm0,%xmm11					# t=1.0-r for cos
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lsincosarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lsinarray+0x20(%rip),%xmm5			# c3+x2c4
+	addpd	.Lsincosarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lsinarray(%rip),%xmm9			# c1+x2c2
+
+	mulpd	%xmm1,%xmm3					# x3
+	movapd	%xmm12,%xmm2					# upper x4 for cos
+	movsd	%xmm7,%xmm2					# lower x2 for sin
+	mulsd	%xmm10,%xmm2					# lower x3=x2*x for sin
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	movlhps	%xmm11,%xmm10					# t for upper cos and x for lower sin
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zszc
+
+	mulpd	%xmm3,%xmm5					# x3 * zs
+	mulpd	%xmm2,%xmm4					# upper=x4 * zc
+								# lower=x3 * zs
+
+	addpd	%xmm1,%xmm5					# +x
+	addpd   %xmm10,%xmm4					# +t upper, +x lower
+
+	jmp 	.L__vrs4_sinf_cleanup
+
+.align 16
+.Lsinsin_sincos_piby4:		# Derived from sincos_coscos
+
+	movsd	%xmm2,%xmm0					# x2
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+	movsd	.L__real_3ff0000000000000(%rip),%xmm11
+
+	movdqa	.Lcossinarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lsinarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lcossinarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lsinarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	mulpd	%xmm2,%xmm12					# x4
+	subsd	%xmm0,%xmm11					# t=1.0-r for cos
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lcossinarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lsinarray+0x20(%rip),%xmm5			# c3+x2c4
+	addpd	.Lcossinarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lsinarray(%rip),%xmm9			# c1+x2c2
+
+	mulpd	%xmm1,%xmm3					# x3
+	mulpd	%xmm10,%xmm2					# upper x3 for sin
+	mulsd	%xmm10,%xmm2					# lower x4 for cos
+
+	movhlps	%xmm10,%xmm6
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	movlhps	%xmm6,%xmm11
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zszc
+
+	mulpd	%xmm3,%xmm5					# x3 * zs
+	mulpd	%xmm2,%xmm4					# lower=x4 * zc
+								# upper=x3 * zs
+
+	addpd	%xmm1,%xmm5					# +x
+	addpd   %xmm11,%xmm4					# +t lower, +x upper
+
+	jmp 	.L__vrs4_sinf_cleanup
+
+.align 16
+.Lsinsin_sinsin_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+  #x2 = x * x;
+  #(x + x * x2 * (c1 + x2 * (c2 + x2 * (c3 + x2 * c4))));
+
+  #x + x3 * ((c1 + x2 *c2) + x4 * (c3 + x2 * c4));
+
+
+	movapd	%xmm2,%xmm0					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lsinarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lsinarray+0x30(%rip),%xmm5			# c4
+
+	mulpd	%xmm2,%xmm0					# x4
+	mulpd	%xmm3,%xmm11					# x4
+
+	movapd	.Lsinarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lsinarray+0x10(%rip),%xmm9			# c2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	addpd	.Lsinarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lsinarray+0x20(%rip),%xmm5			# c3+x2c4
+
+	mulpd	%xmm10,%xmm2					# x3
+	mulpd	%xmm1,%xmm3					# x3
+
+	addpd	.Lsinarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lsinarray(%rip),%xmm9			# c1+x2c2
+
+	mulpd	%xmm0,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm11,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zs
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm3,%xmm5					# x3 * zs
+
+	addpd	%xmm10,%xmm4					# +x
+	addpd	%xmm1,%xmm5					# +x
+
+	jmp 	.L__vrs4_sinf_cleanup
diff --git a/src/gas/vrs8expf.S b/src/gas/vrs8expf.S
new file mode 100644
index 0000000..b2eb597
--- /dev/null
+++ b/src/gas/vrs8expf.S
@@ -0,0 +1,618 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrs8expf.s
+#
+# A vector implementation of the expf libm function.
+#
+# Prototype:
+#
+#    void vs_expf(int n, float *x, float *y);
+#
+#   Computes e raised to the x power for a eight packed single values.
+#   Places the results into xmm0 an xmm1.
+#  This routine implemented in single precision.  It is slightly
+#  less accurate than the double precision version, but it will
+#  be better for vectorizing.
+# Does not perform error handling, but does return C99 values for error
+# inputs.   Denormal results are truncated to 0.
+
+# This array version is basically a unrolling of the by4 scalar single
+# routine.  The second set of operations is performed by the indented
+# instructions interleaved into the first set.
+# The scheduling is done by trial and error.  The resulting code represents
+# the best time of many variations.  It would seem more interleaving could
+# be done, as there is a long stretch of the second computation that is not
+# interleaved.  But moving any of this code forward makes the routine
+# slower.
+#
+#
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+
+# define local variable storage offsets
+.equ    p_ux,0x00               #qword
+.equ    p_ux2,0x010             #qword
+
+.equ    save_xa,0x020           #qword
+.equ    save_ya,0x028           #qword
+.equ    save_nv,0x030           #qword
+
+
+.equ    p_iter,0x038            # qword storage for number of loop iterations
+
+.equ    p_j,0x040               # second temporary for get/put bits operation
+.equ    p_m,0x050               #qword
+.equ    p_j2,0x060              # second temporary for exponent multiply
+.equ    p_m2,0x070              #qword
+.equ    save_rbx,0x080          #qword
+
+
+.equ    stack_size,0x098
+
+
+# parameters passed by gcc as:
+# xmm0 - __m128d x1
+# xmm1 - __m128d x2
+
+    .text
+    .align 16
+    .p2align 4,,15
+.globl __vrs8_expf
+    .type   __vrs8_expf,@function
+__vrs8_expf:
+        sub             $stack_size,%rsp
+        mov             %rbx,save_rbx(%rsp)
+
+
+# Process the array 8 values at a time.
+
+	movaps	.L__real_thirtytwo_by_log2(%rip),%xmm3	#
+
+	movaps	 %xmm0,p_ux(%rsp)
+        maxps   .L__real_m8192(%rip),%xmm0
+		movaps	 %xmm1,p_ux2(%rsp)
+                maxps   .L__real_m8192(%rip),%xmm1
+		movaps	%xmm1,%xmm6
+#        /* Find m, z1 and z2 such that exp(x) = 2**m * (z1 + z2) */
+#      Step 1. Reduce the argument.
+        #    r = x * thirtytwo_by_logbaseof2;
+        movaps  .L__real_thirtytwo_by_log2(%rip),%xmm2  #
+
+        mulps   %xmm0,%xmm2
+        xor             %rax,%rax
+        minps   .L__real_8192(%rip),%xmm2
+                movaps  .L__real_thirtytwo_by_log2(%rip),%xmm5  #
+
+                mulps   %xmm6,%xmm5
+        	minps   .L__real_8192(%rip),%xmm5   # protect against large input values
+
+#    /* Set n = nearest integer to r */
+        cvtps2dq        %xmm2,%xmm3
+        lea             .L__two_to_jby32_table(%rip),%rdi
+        cvtdq2ps        %xmm3,%xmm1
+
+                cvtps2dq        %xmm5,%xmm8
+                cvtdq2ps        %xmm8,%xmm7
+#    r1 = x - n * logbaseof2_by_32_lead;
+        movaps  .L__real_log2_by_32_head(%rip),%xmm2
+        mulps   %xmm1,%xmm2
+        subps   %xmm2,%xmm0                             # r1 in xmm0,
+
+                movaps  .L__real_log2_by_32_head(%rip),%xmm5
+                mulps   %xmm7,%xmm5
+                subps   %xmm5,%xmm6                             # r1 in xmm6,
+
+
+#    r2 = - n * logbaseof2_by_32_lead;
+        mulps   .L__real_log2_by_32_tail(%rip),%xmm1
+                mulps   .L__real_log2_by_32_tail(%rip),%xmm7
+
+#    j = n & 0x0000001f;
+        movdqa  %xmm3,%xmm4
+        movdqa  .L__int_mask_1f(%rip),%xmm2
+                movdqa  %xmm8,%xmm9
+                movdqa  .L__int_mask_1f(%rip),%xmm5
+        pand    %xmm4,%xmm2
+        movdqa   %xmm2,p_j(%rsp)
+#    f1 = two_to_jby32_lead_table[j);
+
+                pand    %xmm9,%xmm5
+                movdqa   %xmm5,p_j2(%rsp)
+
+#    *m = (n - j) / 32;
+        psubd   %xmm2,%xmm4
+        psrad   $5,%xmm4
+        movdqa   %xmm4,p_m(%rsp)
+                psubd   %xmm5,%xmm9
+                psrad   $5,%xmm9
+                movdqa   %xmm9,p_m2(%rsp)
+
+        movaps  %xmm0,%xmm3
+        addps   %xmm1,%xmm3                             # r = r1+ r2
+
+        mov             p_j(%rsp),%eax                  # get an individual index
+
+                movaps  %xmm6,%xmm8
+        mov             (%rdi,%rax,4),%edx              # get the f1 value
+                addps   %xmm7,%xmm8                             # r = r1+ r2
+        mov              %edx,p_j(%rsp)                         # save the f1 value
+
+
+#      Step 2. Compute the polynomial.
+#    q = r1 +
+#              r*r*( 5.00000000000000008883e-01 +
+#                      r*( 1.66666666665260878863e-01 +
+#                      r*( 4.16666666662260795726e-02 +
+#                      r*( 8.33336798434219616221e-03 +
+#                      r*( 1.38889490863777199667e-03 )))));
+#    q = r + r^2/2 + r^3/6 + r^4/24 + r^5/120 + r^6/720
+#    q = r + r^2/2 + r^3/6 + r^4/24 good enough for single precision
+        movaps  %xmm3,%xmm4
+        movaps  %xmm3,%xmm2
+        mulps   %xmm2,%xmm2                     # x*x
+        mulps   .L__real_1_24(%rip),%xmm4       # /24
+
+        mov             p_j+4(%rsp),%eax                        # get an individual index
+
+        mov             (%rdi,%rax,4),%edx              # get the f1 value
+        mov              %edx,p_j+4(%rsp)                       # save the f1 value
+
+
+        addps   .L__real_1_6(%rip),%xmm4                # +1/6
+
+        mulps   %xmm2,%xmm3                     # x^3
+        mov             p_j+8(%rsp),%eax                        # get an individual index
+
+        mov             (%rdi,%rax,4),%edx              # get the f1 value
+        mov              %edx,p_j+8(%rsp)                       # save the f1 value
+
+        mulps   .L__real_half(%rip),%xmm2       # x^2/2
+        mov             p_j+12(%rsp),%eax                       # get an individual index
+
+        mov             (%rdi,%rax,4),%edx              # get the f1 value
+        mov              %edx,p_j+12(%rsp)                      # save the f1 value
+
+        mulps   %xmm3,%xmm4                     # *x^3
+                mov             p_j2(%rsp),%eax                 # get an individual index
+                mov             (%rdi,%rax,4),%edx              # get the f1 value
+                mov              %edx,p_j2(%rsp)                        # save the f1 value
+
+
+        addps   %xmm4,%xmm1                     # +r2
+
+        addps   %xmm2,%xmm1                     # + x^2/2
+        addps   %xmm1,%xmm0                     # +r1
+
+                movaps  %xmm8,%xmm9
+                mov             p_j2+4(%rsp),%eax                # get an individual index
+                movaps  %xmm8,%xmm5
+                mulps   %xmm5,%xmm5                     # x*x
+                mulps   .L__real_1_24(%rip),%xmm9       # /24
+
+                movaps  %xmm8,%xmm5
+                mulps   %xmm5,%xmm5                     # x*x
+                mulps   .L__real_1_24(%rip),%xmm9       # /24
+
+                mov             (%rdi,%rax,4),%edx              # get the f1 value
+                mov              %edx,p_j2+4(%rsp)                      # save the f1 value
+
+
+# deal with infinite or denormal results
+        movdqa  p_m(%rsp),%xmm1
+        movdqa  p_m(%rsp),%xmm2
+        pcmpgtd .L__int_127(%rip),%xmm2
+        pminsw  .L__int_128(%rip),%xmm1 # ceil at 128
+        movmskps        %xmm2,%eax
+        test            $0x0f,%eax
+
+        paddd   .L__int_127(%rip),%xmm1 # add bias
+
+#    *z2 = f2 + ((f1 + f2) * q);
+        mulps   p_j(%rsp),%xmm0         # * f1
+        addps   p_j(%rsp),%xmm0         # + f1
+        jnz             .L__exp_largef
+.L__check1:
+
+        pxor    %xmm2,%xmm2                             # floor at 0
+        pmaxsw  %xmm2,%xmm1
+
+        pslld   $23,%xmm1                                       # build 2^n
+
+        movaps  %xmm1,%xmm2
+
+
+
+# check for infinity or nan
+        movaps  p_ux(%rsp),%xmm1
+        andps   .L__real_infinity(%rip),%xmm1
+        cmpps   $0,.L__real_infinity(%rip),%xmm1
+        movmskps        %xmm1,%ebx
+        test            $0x0f,%ebx
+
+# end of splitexp
+#        /* Scale (z1 + z2) by 2.0**m */
+#      Step 3. Reconstitute.
+
+	mulps	%xmm2,%xmm0						# result *= 2^n
+
+# we'd like to avoid a branch, and can use cmp's and and's to
+# eliminate them.  But it adds cycles for normal cases
+# to handle events that are supposed to be exceptions.
+#  Using this branch with the
+# check above results in faster code for the normal cases.
+# And branch mispredict penalties should only come into
+# play for nans and infinities.
+	jnz		.L__exp_naninf
+.L__vsa_bottom1:
+
+                #    q = r + r^2/2 + r^3/6 + r^4/24 good enough for single precision
+                addps   .L__real_1_6(%rip),%xmm9                # +1/6
+
+                mulps   %xmm5,%xmm8                     # x^3
+                mov             p_j2+8(%rsp),%eax               # get an individual index
+                mov             (%rdi,%rax,4),%edx              # get the f1 value
+                mov              %edx,p_j2+8(%rsp)              # save the f1 value
+
+                mulps   .L__real_half(%rip),%xmm5       # x^2/2
+                mulps   %xmm8,%xmm9                     # *x^3
+
+                mov             p_j2+12(%rsp),%eax              # get an individual index
+                mov             (%rdi,%rax,4),%edx              # get the f1 value
+                mov              %edx,p_j2+12(%rsp)             # save the f1 value
+
+                addps   %xmm9,%xmm7                     # +r2
+
+                addps   %xmm5,%xmm7                     # + x^2/2
+                addps   %xmm7,%xmm6                     # +r1
+
+
+                # deal with infinite or denormal results
+                movdqa  p_m2(%rsp),%xmm7
+                movdqa  p_m2(%rsp),%xmm5
+                pcmpgtd .L__int_127(%rip),%xmm5
+                pminsw  .L__int_128(%rip),%xmm7 # ceil at 128
+                movmskps        %xmm5,%eax
+                test            $0x0f,%eax
+
+                paddd   .L__int_127(%rip),%xmm7 # add bias
+
+        #    *z2 = f2 + ((f1 + f2) * q);
+                mulps   p_j2(%rsp),%xmm6                # * f1
+                addps   p_j2(%rsp),%xmm6                # + f1
+                jnz             .L__exp_largef2
+.L__check2:
+                pxor    %xmm1,%xmm1                             # floor at 0
+                pmaxsw  %xmm1,%xmm7
+
+                pslld   $23,%xmm7                                       # build 2^n
+
+                movaps  %xmm7,%xmm1
+
+
+                # check for infinity or nan
+                movaps  p_ux2(%rsp),%xmm7
+                andps   .L__real_infinity(%rip),%xmm7
+                cmpps   $0,.L__real_infinity(%rip),%xmm7
+                movmskps        %xmm7,%ebx
+                test            $0x0f,%ebx
+
+
+		# end of splitexp
+		#        /* Scale (z1 + z2) by 2.0**m */
+		#      Step 3. Reconstitute.
+
+		mulps	%xmm6,%xmm1						# result *= 2^n
+
+		jnz			.L__exp_naninf2
+
+.L__vsa_bottom2:
+
+
+
+#
+.L__final_check:
+	mov		save_rbx(%rsp),%rbx		# restore rbx
+	add		$stack_size,%rsp
+	ret
+
+# at least one of the numbers needs special treatment
+.L__exp_naninf:
+	lea		p_ux(%rsp),%rcx
+	lea		p_j(%rsp),%rsi
+	call  .L__fexp_naninf
+	jmp		.L__vsa_bottom1
+.L__exp_naninf2:
+	lea		p_ux2(%rsp),%rcx
+	lea		p_j(%rsp),%rsi
+	movaps	%xmm0,%xmm2
+	movaps	%xmm1,%xmm0
+	call  .L__fexp_naninf
+	movaps	%xmm0,%xmm1
+	movaps	%xmm2,%xmm0
+	jmp		.L__vsa_bottom2
+
+#  deal with nans and infinities
+# This subroutine checks a packed single for nans and infinities and
+# produces the proper result from the exceptional inputs
+# Register assumptions:
+# Inputs:
+# rbx - mask of errors
+# xmm0 - computed result vector
+# Outputs:
+# xmm0 - new result vector
+# %rax,rdx,rbx,%xmm2 all modified.
+
+.L__fexp_naninf:
+	sub		$0x018,%rsp
+	movaps	%xmm0,(%rsi)	# save the computed values
+	test	$1,%ebx					# first value?
+	jz		.L__Lni2
+	mov		0(%rcx),%edx	# get the input
+	call	.L__naninf
+	mov		%edx,0(%rsi)	# copy the result
+.L__Lni2:
+	test	$2,%ebx					# second value?
+	jz		.L__Lni3
+	mov		4(%rcx),%edx	# get the input
+	call	.L__naninf
+	mov		%edx,4(%rsi)	# copy the result
+.L__Lni3:
+	test	$4,%ebx					# third value?
+	jz		.L__Lni4
+	mov		8(%rcx),%edx	# get the input
+	call	.L__naninf
+	mov		%edx,8(%rsi)	# copy the result
+.L__Lni4:
+	test	$8,%ebx					# fourth value?
+	jz		.L__Lnie
+	mov		12(%rcx),%edx	# get the input
+	call	.L__naninf
+	mov		%edx,12(%rsi)	# copy the result
+.L__Lnie:
+	movaps	(%rsi),%xmm0	# get the answers
+	add		$0x018,%rsp
+	ret
+
+#
+# a simple subroutine to check a scalar input value for infinity
+# or NaN and return the correct result
+# expects input in .Land,%edx returns value in edx.  Destroys eax.
+.L__naninf:
+	mov		$0x0007FFFFF,%eax
+	test	%eax,%edx
+	jnz		.L__enan		# jump if mantissa not zero, so it's a NaN
+# inf
+	mov		%edx,%eax
+	rcl		$1,%eax
+	jnc		.L__r			# exp(+inf) = inf
+	xor		%edx,%edx		# exp(-inf) = 0
+	jmp		.L__r
+
+#NaN
+.L__enan:
+	mov		$0x000400000,%eax	# convert to quiet
+	or		%eax,%edx
+.L__r:
+	ret
+        .align  16
+#  deal with m > 127.  In some instances, rounding during calculations
+#  can result in infinity when it shouldn't.  For these cases, we scale
+#  m down, and scale the mantissa up.
+
+.L__exp_largef:
+        movdqa    %xmm0,p_j(%rsp)    # save the mantissa portion
+        movdqa    %xmm1,p_m(%rsp)       # save the exponent portion
+        mov       %eax,%ecx              # save the error mask
+        test    $1,%ecx                  # first value?
+        jz       .L__Lf2
+        mov      p_m(%rsp),%edx # get the exponent
+        sub      $1,%edx                # scale it down
+        mov      %edx,p_m(%rsp)       # save the exponent
+        movss   p_j(%rsp),%xmm3     # get the mantissa
+        mulss   .L__real_two(%rip),%xmm3        # scale it up
+        movss    %xmm3,p_j(%rsp)   # save the mantissa
+.L__Lf2:
+        test    $2,%ecx                 # second value?
+        jz       .L__Lf3
+        mov      p_m+4(%rsp),%edx # get the exponent
+        sub      $1,%edx                # scale it down
+        mov      %edx,p_m+4(%rsp)       # save the exponent
+        movss   p_j+4(%rsp),%xmm3     # get the mantissa
+        mulss   .L__real_two(%rip),%xmm3        # scale it up
+        movss     %xmm3,p_j+4(%rsp)   # save the mantissa
+.L__Lf3:
+        test    $4,%ecx                 # third value?
+        jz       .L__Lf4
+        mov      p_m+8(%rsp),%edx # get the exponent
+        sub      $1,%edx                # scale it down
+        mov      %edx,p_m+8(%rsp)       # save the exponent
+        movss   p_j+8(%rsp),%xmm3     # get the mantissa
+        mulss   .L__real_two(%rip),%xmm3        # scale it up
+        movss    %xmm3,p_j+8(%rsp)   # save the mantissa
+.L__Lf4:
+        test    $8,%ecx                                 # fourth value?
+        jz       .L__Lfe
+        mov      p_m+12(%rsp),%edx        # get the exponent
+        sub      $1,%edx                 # scale it down
+        mov      %edx,p_m+12(%rsp)      # save the exponent
+        movss   p_j+12(%rsp),%xmm3    # get the mantissa
+        mulss   .L__real_two(%rip),%xmm3        # scale it up
+        movss     %xmm3,p_j+12(%rsp)  # save the mantissa
+.L__Lfe:
+        movaps  p_j(%rsp),%xmm0      # restore the mantissa portion back
+        movdqa  p_m(%rsp),%xmm1         # restore the exponent portion
+        jmp             .L__check1
+
+        .align  16
+
+.L__exp_largef2:
+        movdqa    %xmm6,p_j(%rsp)    # save the mantissa portion
+        movdqa    %xmm7,p_m2(%rsp)      # save the exponent portion
+        mov             %eax,%ecx                                       # save the error mask
+        test    $1,%ecx                                 # first value?
+        jz              .L__Lf22
+        mov             p_m2+0(%rsp),%edx       # get the exponent
+        sub             $1,%edx                                         # scale it down
+        mov               %edx,p_m2+0(%rsp)     # save the exponent
+        movss   p_j+0(%rsp),%xmm3    # get the mantissa
+        mulss   .L__real_two(%rip),%xmm3        # scale it up
+        movss     %xmm3,p_j+0(%rsp)  # save the mantissa
+.L__Lf22:
+        test    $2,%ecx                                 # second value?
+        jz              .L__Lf32
+        mov             p_m2+4(%rsp),%edx       # get the exponent
+        sub             $1,%edx                                         # scale it down
+        mov               %edx,p_m2+4(%rsp)     # save the exponent
+        movss   p_j+4(%rsp),%xmm3    # get the mantissa
+        mulss   .L__real_two(%rip),%xmm3        # scale it up
+        movss     %xmm3,p_j+4(%rsp)  # save the mantissa
+.L__Lf32:
+        test    $4,%ecx                                 # third value?
+        jz              .L__Lf42
+        mov             p_m2+8(%rsp),%edx       # get the exponent
+        sub             $1,%edx                                         # scale it down
+        mov               %edx,p_m2+8(%rsp)     # save the exponent
+        movss   p_j+8(%rsp),%xmm3    # get the mantissa
+        mulss   .L__real_two(%rip),%xmm3        # scale it up
+        movss     %xmm3,p_j+8(%rsp)  # save the mantissa
+.L__Lf42:
+        test    $8,%ecx                                 # fourth value?
+        jz              .L__Lfe2
+        mov             p_m2+12(%rsp),%edx      # get the exponent
+        sub             $1,%edx                                         # scale it down
+        mov               %edx,p_m2+12(%rsp)    # save the exponent
+        movss   p_j+12(%rsp),%xmm3   # get the mantissa
+        mulss   .L__real_two(%rip),%xmm3        # scale it up
+        movss     %xmm3,p_j+12(%rsp) # save the mantissa
+.L__Lfe2:
+        movaps  p_j(%rsp),%xmm6      # restore the mantissa portion back
+        movdqa  p_m2(%rsp),%xmm7                # restore the exponent portion
+        jmp             .L__check2
+
+	.data		# MUCH better performance without this on my tests
+        .align  64
+.L__real_half:                  .long 0x03f000000       # 1/2
+                                .long 0x03f000000
+                                .long 0x03f000000
+                                .long 0x03f000000
+.L__real_two:                   .long 0x40000000        # 2
+                                .long 0x40000000
+                                .long 0x40000000
+                                .long 0x40000000
+
+.L__real_8192:                  .long 0x46000000        # 8192, to protect against really large numbers
+                                .long 0x46000000
+                                .long 0x46000000
+                                .long 0x46000000
+.L__real_m8192:                 .long 0xC6000000        # -8192, to protect against really small numbers
+                                .long 0xC6000000
+                                .long 0xC6000000
+                                .long 0xC6000000
+.L__real_thirtytwo_by_log2:     .long 0x04238AA3B       # thirtytwo_by_log2
+                                .long 0x04238AA3B
+                                .long 0x04238AA3B
+                                .long 0x04238AA3B
+.L__real_log2_by_32:            .long 0x03CB17218       # log2_by_32
+                                .long 0x03CB17218
+                                .long 0x03CB17218
+                                .long 0x03CB17218
+.L__real_log2_by_32_head:       .long 0x03CB17000       # log2_by_32
+                                .long 0x03CB17000
+                                .long 0x03CB17000
+                                .long 0x03CB17000
+.L__real_log2_by_32_tail:       .long 0x0B585FDF4       # log2_by_32
+                                .long 0x0B585FDF4
+                                .long 0x0B585FDF4
+                                .long 0x0B585FDF4
+.L__real_1_6:                   .long 0x03E2AAAAB       # 0.16666666666 used in polynomial
+                                .long 0x03E2AAAAB
+                                .long 0x03E2AAAAB
+                                .long 0x03E2AAAAB
+.L__real_1_24:                  .long 0x03D2AAAAB       # 0.041666668 used in polynomial
+                                .long 0x03D2AAAAB
+                                .long 0x03D2AAAAB
+                                .long 0x03D2AAAAB
+.L__real_1_120:                 .long 0x03C088889       # 0.0083333338 used in polynomial
+                                .long 0x03C088889
+                                .long 0x03C088889
+                                .long 0x03C088889
+.L__real_infinity:              .long 0x07f800000       # infinity
+                                .long 0x07f800000
+                                .long 0x07f800000
+                                .long 0x07f800000
+.L__int_mask_1f:                .long 0x00000001f
+                                .long 0x00000001f
+                                .long 0x00000001f
+                                .long 0x00000001f
+.L__int_128:                    .long 0x000000080
+                                .long 0x000000080
+                                .long 0x000000080
+                                .long 0x000000080
+.L__int_127:                    .long 0x00000007f
+                                .long 0x00000007f
+                                .long 0x00000007f
+                                .long 0x00000007f
+
+.L__two_to_jby32_table:
+        .long   0x03F800000             # 1.0000000000000000
+        .long   0x03F82CD87             # 1.0218971486541166
+        .long   0x03F85AAC3             # 1.0442737824274138
+        .long   0x03F88980F             # 1.0671404006768237
+        .long   0x03F8B95C2             # 1.0905077326652577
+        .long   0x03F8EA43A             # 1.1143867425958924
+        .long   0x03F91C3D3             # 1.1387886347566916
+        .long   0x03F94F4F0             # 1.1637248587775775
+        .long   0x03F9837F0             # 1.1892071150027210
+        .long   0x03F9B8D3A             # 1.2152473599804690
+        .long   0x03F9EF532             # 1.2418578120734840
+        .long   0x03FA27043             # 1.2690509571917332
+        .long   0x03FA5FED7             # 1.2968395546510096
+        .long   0x03FA9A15B             # 1.3252366431597413
+        .long   0x03FAD583F             # 1.3542555469368927
+        .long   0x03FB123F6             # 1.3839098819638320
+        .long   0x03FB504F3             # 1.4142135623730951
+        .long   0x03FB8FBAF             # 1.4451808069770467
+        .long   0x03FBD08A4             # 1.4768261459394993
+        .long   0x03FC12C4D             # 1.5091644275934228
+        .long   0x03FC5672A             # 1.5422108254079407
+        .long   0x03FC9B9BE             # 1.5759808451078865
+        .long   0x03FCE248C             # 1.6104903319492543
+        .long   0x03FD2A81E             # 1.6457554781539649
+        .long   0x03FD744FD             # 1.6817928305074290
+        .long   0x03FDBFBB8             # 1.7186192981224779
+        .long   0x03FE0CCDF             # 1.7562521603732995
+        .long   0x03FE5B907             # 1.7947090750031072
+        .long   0x03FEAC0C7             # 1.8340080864093424
+        .long   0x03FEFE4BA             # 1.8741676341103000
+        .long   0x03FF5257D             # 1.9152065613971474
+        .long   0x03FFA83B3             # 1.9571441241754002
+        .long 0                                 # for alignment
+
diff --git a/src/gas/vrs8log10f.S b/src/gas/vrs8log10f.S
new file mode 100644
index 0000000..b0a2a67
--- /dev/null
+++ b/src/gas/vrs8log10f.S
@@ -0,0 +1,967 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrs8logf.s
+#
+# A vector implementation of the logf libm function.
+#  This routine implemented in single precision.  It is slightly
+#  less accurate than the double precision version, but it will
+#  be better for vectorizing.
+#
+# Prototype:
+#
+#    __m128,__m128 __vrs8_log10f(__m128 x1, __m128 x2);
+#
+#   Computes the natural log of x for eight packed single values.
+#   Places the results into xmm0 and xmm1.
+#   Returns proper C99 values, but may not raise status flags properly.
+#   Less than 1 ulp of error.
+#
+# This array version is basically a unrolling of the by4 scalar single
+# routine.  The second set of operations is performed by the indented
+# instructions interleaved into the first set.
+# The scheduling is done by trial and error.  The resulting code represents
+# the best time of many variations.  It would seem more interleaving could
+# be done, as there is a long stretch of the second computation that is not
+# interleaved.  But moving any of this code forward makes the routine
+# slower.
+#
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+    .text
+    .align 16
+    .p2align 4,,15
+
+# define local variable storage offsets
+.equ	p_x,0			# save x
+.equ	p_idx,0x010		# xmmword index
+.equ	p_z1,0x020		# xmmword index
+.equ	p_q,0x030		# xmmword index
+.equ	p_corr,0x040		# xmmword index
+.equ	p_omask,0x050		# xmmword index
+.equ	save_xmm6,0x060		#
+.equ	save_rbx,0x070		#
+.equ	save_xmm7,0x080		#
+.equ	save_xmm8,0x090		#
+.equ	save_xmm9,0x0a0		#
+.equ	save_xmm10,0x0b0		#
+.equ	save_xmm11,0x0c0		#
+.equ	save_xmm12,0x0d0		#
+.equ	save_xmm13,0x0d0		#
+.equ	p_x2,0x0100		# save x
+.equ	p_idx2,0x0110		# xmmword index
+.equ	p_z12,0x0120		# xmmword index
+.equ	p_q2,0x0130		# xmmword index
+
+.equ	stack_size,0x0168
+
+
+
+.globl __vrs8_log10f
+    .type   __vrs8_log10f,@function
+__vrs8_log10f:
+	sub		$stack_size,%rsp
+	mov		%rbx,save_rbx(%rsp)	# save rbx
+
+# check e as a special case
+	movdqa	%xmm0,p_x(%rsp)	# save x
+		movdqa	%xmm1,p_x2(%rsp)	# save x
+#	movdqa	%xmm0,%xmm2
+#	cmpps	$0,.L__real_ef(%rip),%xmm2
+#	movmskps	%xmm2,%r9d
+
+		movdqa	%xmm1,%xmm12
+		movdqa	%xmm1,%xmm9
+		movaps	%xmm1,%xmm7
+
+#
+# compute the index into the log tables
+#
+	movdqa	%xmm0,%xmm3
+	movaps	%xmm0,%xmm1
+	psrld	$23,%xmm3
+
+	#
+	# compute the index into the log tables
+	#
+		psrld	$23,%xmm9
+		subps	.L__real_one(%rip),%xmm7
+		psubd	.L__mask_127(%rip),%xmm9
+	subps	.L__real_one(%rip),%xmm1
+	psubd	.L__mask_127(%rip),%xmm3
+		cvtdq2ps	%xmm9,%xmm13			# xexp
+
+		movdqa	%xmm12,%xmm9
+		pand	.L__real_mant(%rip),%xmm9
+		xor		%r8,%r8
+		movdqa	%xmm9,%xmm8
+		movaps	.L__real_half(%rip),%xmm11							# .5
+	cvtdq2ps	%xmm3,%xmm6			# xexp
+
+	movdqa	%xmm0,%xmm3
+	pand	.L__real_mant(%rip),%xmm3
+	xor		%r8,%r8
+	movdqa	%xmm3,%xmm2
+	movaps	.L__real_half(%rip),%xmm5							# .5
+
+#/* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+	psrld	$16,%xmm3
+	lea		.L__np_ln_lead_table(%rip),%rdx
+	movdqa	%xmm3,%xmm4
+		psrld	$16,%xmm9
+		movdqa	%xmm9,%xmm10
+		psrld	$1,%xmm9
+	psrld	$1,%xmm3
+	paddd	.L__mask_040(%rip),%xmm3
+	pand	.L__mask_001(%rip),%xmm4
+	paddd	%xmm4,%xmm3
+	cvtdq2ps	%xmm3,%xmm1
+	#/* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+		paddd	.L__mask_040(%rip),%xmm9
+		pand	.L__mask_001(%rip),%xmm10
+		paddd	%xmm10,%xmm9
+		cvtdq2ps	%xmm9,%xmm7
+	packssdw	%xmm3,%xmm3
+	movq	%xmm3,p_idx(%rsp)
+		packssdw	%xmm9,%xmm9
+		movq	%xmm9,p_idx2(%rsp)
+
+
+# reduce and get u
+	movdqa	%xmm0,%xmm3
+	orps		.L__real_half(%rip),%xmm2
+
+
+	mulps	.L__real_3c000000(%rip),%xmm1				# f1 = index/128
+	# reduce and get u
+
+
+	subps	%xmm1,%xmm2											# f2 = f - f1
+	mulps	%xmm2,%xmm5
+	addps	%xmm5,%xmm1
+
+	divps	%xmm1,%xmm2				# u
+
+		movdqa	%xmm12,%xmm9
+		orps		.L__real_half(%rip),%xmm8
+
+
+		mulps	.L__real_3c000000(%rip),%xmm7				# f1 = index/128
+		subps	%xmm7,%xmm8											# f2 = f - f1
+		mulps	%xmm8,%xmm11
+		addps	%xmm11,%xmm7
+
+
+	mov		p_idx(%rsp),%rcx 			# get the indexes
+	mov		%cx,%r8w
+	ror		$16,%rcx
+	mov		-256(%rdx,%r8,4),%eax		# get the f1 value
+
+	mov		%cx,%r8w
+	ror		$16,%rcx
+	mov		-256(%rdx,%r8,4),%ebx		# get the f1 value
+	shl		$32,%rbx
+	or		%rbx,%rax
+	mov		 %rax,p_z1(%rsp) 			# save the f1 values
+
+	mov		%cx,%r8w
+	ror		$16,%rcx
+	mov		-256(%rdx,%r8,4),%eax		# get the f1 value
+
+	mov		%cx,%r8w
+	ror		$16,%rcx
+	or		-256(%rdx,%r8,4),%ebx		# get the f1 value
+	shl		$32,%rbx
+	or		%rbx,%rax
+	mov		 %rax,p_z1+8(%rsp) 			# save the f1 value
+		divps	%xmm7,%xmm8				# u
+		lea		.L__np_ln_lead_table(%rip),%rdx
+		mov		p_idx2(%rsp),%rcx 			# get the indexes
+		mov		%cx,%r8w
+		ror		$16,%rcx
+		mov		-256(%rdx,%r8,4),%eax		# get the f1 value
+
+		mov		%cx,%r8w
+		ror		$16,%rcx
+		mov		-256(%rdx,%r8,4),%ebx		# get the f1 value
+		shl		$32,%rbx
+		or		%rbx,%rax
+		mov		 %rax,p_z12(%rsp) 			# save the f1 values
+
+		mov		%cx,%r8w
+		ror		$16,%rcx
+		mov		-256(%rdx,%r8,4),%eax		# get the f1 value
+
+		mov		%cx,%r8w
+		ror		$16,%rcx
+		or		-256(%rdx,%r8,4),%ebx		# get the f1 value
+		shl		$32,%rbx
+		or		%rbx,%rax
+		mov		 %rax,p_z12+8(%rsp) 			# save the f1 value
+# solve for ln(1+u)
+	movaps	%xmm2,%xmm1				# u
+	mulps	%xmm2,%xmm2				# u^2
+	movaps	%xmm2,%xmm5
+	movaps	.L__real_cb3(%rip),%xmm3
+	mulps	%xmm2,%xmm3				#Cu2
+	mulps	%xmm1,%xmm5				# u^3
+	addps	.L__real_cb2(%rip),%xmm3 #B+Cu2
+	movaps	%xmm2,%xmm4
+	mulps	%xmm5,%xmm4				# u^5
+	movaps	.L__real_log2_lead(%rip),%xmm2
+
+	mulps	.L__real_cb1(%rip),%xmm5 #Au3
+	addps	%xmm5,%xmm1				# u+Au3
+	mulps	%xmm3,%xmm4				# u5(B+Cu2)
+
+	lea		.L__np_ln_tail_table(%rip),%rdx
+	addps	%xmm4,%xmm1				# poly
+
+# recombine
+	mov		p_idx(%rsp),%rcx 			# get the indexes
+	mov		%cx,%r8w
+	shr		$16,%rcx
+	mov		-256(%rdx,%r8,4),%eax		# get the f2 value
+
+	mov		%cx,%r8w
+	shr		$16,%rcx
+	or		-256(%rdx,%r8,4),%ebx		# get the f2 value
+	shl		$32,%rbx
+	or		%rbx,%rax
+	mov		 %rax,p_q(%rsp) 			# save the f2 value
+
+	mov		%cx,%r8w
+	shr		$16,%rcx
+	mov		-256(%rdx,%r8,4),%eax		# get the f2 value
+
+	mov		%cx,%r8w
+	mov		-256(%rdx,%r8,4),%ebx		# get the f2 value
+	shl		$32,%rbx
+	or		%rbx,%rax
+	mov		 %rax,p_q+8(%rsp) 			# save the f2 value
+
+	addps	p_q(%rsp),%xmm1 #z2	+=q
+
+	movaps	p_z1(%rsp),%xmm0			# z1  values
+
+	mulps	%xmm6,%xmm2
+	addps	%xmm2,%xmm0				#r1
+	movaps	%xmm0,%xmm2
+	mulps	.L__real_log2_tail(%rip),%xmm6
+	addps	%xmm6,%xmm1				#r2
+	movaps	%xmm1,%xmm3
+
+#	logef to log10f
+	mulps 	.L__real_log10e_tail(%rip),%xmm1
+	mulps 	.L__real_log10e_tail(%rip),%xmm0
+	mulps 	.L__real_log10e_lead(%rip),%xmm3
+	mulps 	.L__real_log10e_lead(%rip),%xmm2
+	addps 	%xmm1,%xmm0
+	addps 	%xmm3,%xmm0
+	addps	%xmm2,%xmm0
+#	addps	%xmm1,%xmm0
+
+
+
+# check for e
+#	test		$0x0f,%r9d
+#	jnz			.L__vlogf_e
+.L__f1:
+
+# check for negative numbers or zero
+	xorps	%xmm1,%xmm1
+	cmpps	$1,p_x(%rsp),%xmm1	# 0 greater than =?. catches NaNs also.
+	movmskps	%xmm1,%r9d
+	cmp		$0x0f,%r9d
+	jnz		.L__z_or_neg
+
+.L__f2:
+##  if +inf
+	movaps	p_x(%rsp),%xmm3
+	cmpps	$0,.L__real_inf(%rip),%xmm3
+	movmskps	%xmm3,%r9d
+	test		$0x0f,%r9d
+	jnz		.L__log_inf
+.L__f3:
+
+	movaps	p_x(%rsp),%xmm3
+	subps	.L__real_one(%rip),%xmm3
+	andps	.L__real_notsign(%rip),%xmm3
+	cmpps	$2,.L__real_threshold(%rip),%xmm3
+	movmskps	%xmm3,%r9d
+	test	$0x0f,%r9d
+	jnz		.L__near_one
+.L__f4:
+
+# finish the second set of calculations
+
+	# solve for ln(1+u)
+		movaps	%xmm8,%xmm7				# u
+		mulps	%xmm8,%xmm8				# u^2
+		movaps	%xmm8,%xmm11
+
+		movaps	.L__real_cb3(%rip),%xmm9
+		mulps	%xmm8,%xmm9				#Cu2
+		mulps	%xmm7,%xmm11				# u^3
+		addps	.L__real_cb2(%rip),%xmm9 #B+Cu2
+		movaps	%xmm8,%xmm10
+		mulps	%xmm11,%xmm10				# u^5
+		movaps	.L__real_log2_lead(%rip),%xmm8
+
+		mulps	.L__real_cb1(%rip),%xmm11 #Au3
+		addps	%xmm11,%xmm7				# u+Au3
+		mulps	%xmm9,%xmm10				# u5(B+Cu2)
+		addps	%xmm10,%xmm7				# poly
+
+
+	# recombine
+		lea		.L__np_ln_tail_table(%rip),%rdx
+		mov		p_idx2(%rsp),%rcx 			# get the indexes
+		mov		%cx,%r8w
+		shr		$16,%rcx
+		mov		-256(%rdx,%r8,4),%eax		# get the f2 value
+
+		mov		%cx,%r8w
+		shr		$16,%rcx
+		or		-256(%rdx,%r8,4),%ebx		# get the f2 value
+		shl		$32,%rbx
+		or		%rbx,%rax
+		mov		 %rax,p_q2(%rsp) 			# save the f2 value
+
+		mov		%cx,%r8w
+		shr		$16,%rcx
+		mov		-256(%rdx,%r8,4),%eax		# get the f2 value
+
+		mov		%cx,%r8w
+		mov		-256(%rdx,%r8,4),%ebx		# get the f2 value
+		shl		$32,%rbx
+		or		%rbx,%rax
+		mov		 %rax,p_q2+8(%rsp) 			# save the f2 value
+		addps	p_q2(%rsp),%xmm7 #z2	+=q
+		movaps	p_z12(%rsp),%xmm1			# z1  values
+
+		mulps	%xmm13,%xmm8
+		addps	%xmm8,%xmm1				#r1
+		movaps	%xmm1,%xmm8
+		mulps	.L__real_log2_tail(%rip),%xmm13
+		addps	%xmm13,%xmm7				#r2
+		movaps	%xmm7,%xmm9
+
+	#	logef to log10f
+		mulps 	.L__real_log10e_tail(%rip),%xmm7
+		mulps 	.L__real_log10e_tail(%rip),%xmm1
+		mulps 	.L__real_log10e_lead(%rip),%xmm9
+		mulps 	.L__real_log10e_lead(%rip),%xmm8
+		addps 	%xmm7,%xmm1
+		addps 	%xmm9,%xmm1
+		addps	%xmm8,%xmm1
+
+#		addps	%xmm7,%xmm1
+
+	# check e as a special case
+#		movaps	p_x2(%rsp),%xmm10
+#		cmpps	$0,.L__real_ef(%rip),%xmm10
+#		movmskps	%xmm10,%r9d
+	# check for e
+#		test		$0x0f,%r9d
+#		jnz			.L__vlogf_e2
+.L__f12:
+
+	# check for negative numbers or zero
+		xorps	%xmm7,%xmm7
+		cmpps	$1,p_x2(%rsp),%xmm7	# 0 greater than =?. catches NaNs also.
+		movmskps	%xmm7,%r9d
+		cmp		$0x0f,%r9d
+		jnz		.L__z_or_neg2
+
+.L__f22:
+	##  if +inf
+		movaps	p_x2(%rsp),%xmm9
+		cmpps	$0,.L__real_inf(%rip),%xmm9
+		movmskps	%xmm9,%r9d
+		test		$0x0f,%r9d
+		jnz		.L__log_inf2
+.L__f32:
+
+		movaps	p_x2(%rsp),%xmm9
+		subps	.L__real_one(%rip),%xmm9
+		andps	.L__real_notsign(%rip),%xmm9
+		cmpps	$2,.L__real_threshold(%rip),%xmm9
+		movmskps	%xmm9,%r9d
+		test	$0x0f,%r9d
+		jnz		.L__near_one2
+.L__f42:
+
+
+.L__finish:
+	mov		save_rbx(%rsp),%rbx		# restore rbx
+	add		$stack_size,%rsp
+	ret
+
+.L__vlogf_e:
+	movdqa	p_x(%rsp),%xmm2
+	cmpps	$0,.L__real_ef(%rip),%xmm2
+	movdqa	%xmm2,%xmm3
+	andnps	%xmm0,%xmm3							# keep the non-e values
+	andps	.L__real_one(%rip),%xmm2			# setup the 1 values
+	orps	%xmm3,%xmm2							# merge
+	movdqa	%xmm2,%xmm0							# and replace
+	jmp		.L__f1
+
+.L__vlogf_e2:
+		movdqa	p_x2(%rsp),%xmm2
+		cmpps	$0,.L__real_ef(%rip),%xmm2
+		movdqa	%xmm2,%xmm3
+		andnps	%xmm1,%xmm3							# keep the non-e values
+		andps	.L__real_one(%rip),%xmm2			# setup the 1 values
+		orps	%xmm3,%xmm2							# merge
+		movdqa	%xmm2,%xmm1							# and replace
+		jmp		.L__f12
+
+	.align	16
+.L__near_one:
+# saves 10 cycles
+#      r = x - 1.0;
+	movdqa	%xmm3,p_omask(%rsp)	# save ones mask
+	movaps	p_x(%rsp),%xmm3
+	movaps	.L__real_two(%rip),%xmm2
+	subps	.L__real_one(%rip),%xmm3	   # r
+#      u          = r / (2.0 + r);
+	addps	%xmm3,%xmm2
+	movaps	%xmm3,%xmm1
+	divps	%xmm2,%xmm1		# u
+	movaps	.L__real_ca4(%rip),%xmm4	  #D
+	movaps	.L__real_ca3(%rip),%xmm5	  #C
+#      correction = r * u;
+	movaps	%xmm3,%xmm6
+	mulps	%xmm1,%xmm6		# correction
+	movdqa	%xmm6,p_corr(%rsp)	# save correction
+#      u          = u + u;
+	addps	%xmm1,%xmm1		#u
+	movaps	%xmm1,%xmm2
+	mulps	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulps	%xmm1,%xmm5		# Cu
+	movaps	%xmm1,%xmm6
+	mulps	%xmm2,%xmm6		# u^3
+	mulps	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulps	%xmm6,%xmm4		#Du^3
+
+	addps	.L__real_ca1(%rip),%xmm2	# +A
+	movaps	%xmm6,%xmm1
+	mulps	%xmm1,%xmm1		# u^6
+	addps	%xmm4,%xmm5		#Cu+Du3
+
+	mulps	%xmm6,%xmm2		#u3(A+Bu2)
+	mulps	%xmm5,%xmm1		#u6(Cu+Du3)
+	addps	%xmm1,%xmm2
+	subps	p_corr(%rsp),%xmm2		# -correction
+
+#  loge to log10
+	movaps   %xmm3,%xmm5 	#r1=r
+	pand 	.L__mask_lower(%rip),%xmm5
+	subps	%xmm5,%xmm3
+	addps	%xmm3,%xmm2	#r2 = r2 + (r-r1)
+
+	movaps	%xmm5,%xmm3
+	movaps	%xmm2,%xmm1
+
+	mulps 	.L__real_log10e_tail(%rip),%xmm2
+	mulps 	.L__real_log10e_tail(%rip),%xmm3
+	mulps 	.L__real_log10e_lead(%rip),%xmm1
+	mulps 	.L__real_log10e_lead(%rip),%xmm5
+	addps 	%xmm2,%xmm3
+	addps 	%xmm1,%xmm3
+	addps	%xmm5,%xmm3
+#      return r + r2;
+#	addps	%xmm2,%xmm3
+
+	movdqa	p_omask(%rsp),%xmm6
+	movdqa	%xmm6,%xmm2
+	andnps	%xmm0,%xmm6					# keep the non-nearone values
+	andps	%xmm3,%xmm2					# setup the nearone values
+	orps	%xmm6,%xmm2					# merge
+	movdqa	%xmm2,%xmm0					# and replace
+
+	jmp		.L__f4
+
+
+	.align	16
+.L__near_one2:
+# saves 10 cycles
+#      r = x - 1.0;
+		movdqa	%xmm9,p_omask(%rsp)	# save ones mask
+		movaps	p_x2(%rsp),%xmm3
+		movaps	.L__real_two(%rip),%xmm2
+		subps	.L__real_one(%rip),%xmm3	   # r
+	#      u          = r / (2.0 + r);
+		addps	%xmm3,%xmm2
+		movaps	%xmm3,%xmm7
+		divps	%xmm2,%xmm7		# u
+		movaps	.L__real_ca4(%rip),%xmm4	  #D
+		movaps	.L__real_ca3(%rip),%xmm5	  #C
+	#      correction = r * u;
+		movaps	%xmm3,%xmm6
+		mulps	%xmm7,%xmm6		# correction
+		movdqa	%xmm6,p_corr(%rsp)	# save correction
+	#      u          = u + u;
+		addps	%xmm7,%xmm7		#u
+		movaps	%xmm7,%xmm2
+		mulps	%xmm2,%xmm2		#v =u^2
+	#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+		mulps	%xmm7,%xmm5		# Cu
+		movaps	%xmm7,%xmm6
+		mulps	%xmm2,%xmm6		# u^3
+		mulps	.L__real_ca2(%rip),%xmm2	#Bu^2
+		mulps	%xmm6,%xmm4		#Du^3
+
+		addps	.L__real_ca1(%rip),%xmm2	# +A
+		movaps	%xmm6,%xmm7
+		mulps	%xmm7,%xmm7		# u^6
+		addps	%xmm4,%xmm5		#Cu+Du3
+
+		mulps	%xmm6,%xmm2		#u3(A+Bu2)
+		mulps	%xmm5,%xmm7		#u6(Cu+Du3)
+		addps	%xmm7,%xmm2
+		subps	p_corr(%rsp),%xmm2		# -correction
+
+		#loge to log10
+		movaps   %xmm3,%xmm5 	#r1=r
+		pand 	.L__mask_lower(%rip),%xmm5
+		subps	%xmm5,%xmm3
+		addps	%xmm3,%xmm2	#r2 = r2 + (r-r1)
+
+		movaps	%xmm5,%xmm3
+		movaps	%xmm2,%xmm7
+
+		mulps 	.L__real_log10e_tail(%rip),%xmm2
+		mulps 	.L__real_log10e_tail(%rip),%xmm3
+		mulps 	.L__real_log10e_lead(%rip),%xmm7
+		mulps 	.L__real_log10e_lead(%rip),%xmm5
+		addps 	%xmm2,%xmm3
+		addps 	%xmm7,%xmm3
+		addps	%xmm5,%xmm3
+
+	#      return r + r2;
+#		addps	%xmm2,%xmm3
+
+		movdqa	p_omask(%rsp),%xmm6
+		movdqa	%xmm6,%xmm2
+		andnps	%xmm1,%xmm6					# keep the non-nearone values
+		andps	%xmm3,%xmm2					# setup the nearone values
+		orps	%xmm6,%xmm2					# merge
+		movdqa	%xmm2,%xmm1					# and replace
+
+		jmp		.L__f42
+
+# we have a zero, a negative number, or both.
+# the mask is already in .LNaNs,%xmm1 are also picked up here, along with -inf.
+.L__z_or_neg:
+# deal with negatives first
+	movdqa	%xmm1,%xmm3
+	andps	%xmm0,%xmm3							# keep the non-error values
+	andnps	.L__real_nan(%rip),%xmm1			# setup the nan values
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+# check for +/- 0
+	xorps	%xmm1,%xmm1
+	cmpps	$0,p_x(%rsp),%xmm1	# 0 ?.
+	movmskps	%xmm1,%r9d
+	test		$0x0f,%r9d
+	jz		.L__zn2
+
+	movdqa	%xmm1,%xmm3
+	andnps	%xmm0,%xmm3							# keep the non-error values
+	andps	.L__real_ninf(%rip),%xmm1		# ; C99 specs -inf for +-0
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+
+.L__zn2:
+# check for NaNs
+	movaps	p_x(%rsp),%xmm3
+	andps	.L__real_inf(%rip),%xmm3
+	cmpps	$0,.L__real_inf(%rip),%xmm3		# mask for max exponent
+
+	movdqa	p_x(%rsp),%xmm4
+	pand	.L__real_mant(%rip),%xmm4		# mask for non-zero mantissa
+	pcmpeqd	.L__real_zero(%rip),%xmm4
+	pandn	%xmm3,%xmm4							# mask for NaNs
+	movdqa	%xmm4,%xmm2
+	movdqa	p_x(%rsp),%xmm1			# isolate the NaNs
+	pand	%xmm4,%xmm1
+
+	pand	.L__real_qnanbit(%rip),%xmm4		# now we have a mask that will set QNaN bit
+	por		%xmm1,%xmm4							# turn SNaNs to QNaNs
+
+	movdqa	%xmm2,%xmm1
+	andnps	%xmm0,%xmm2							# keep the non-error values
+	orps	%xmm4,%xmm2							# merge
+	movdqa	%xmm2,%xmm0							# and replace
+	xorps	%xmm4,%xmm4
+
+	jmp		.L__f2
+
+# handle only +inf	 log(+inf) = inf
+.L__log_inf:
+	movdqa	%xmm3,%xmm1
+	andnps	%xmm0,%xmm3							# keep the non-error values
+	andps	p_x(%rsp),%xmm1			# setup the +inf values
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+	jmp		.L__f3
+
+
+.L__z_or_neg2:
+	# deal with negatives first
+		movdqa	%xmm7,%xmm3
+		andps	%xmm1,%xmm3							# keep the non-error values
+		andnps	.L__real_nan(%rip),%xmm7			# setup the nan values
+		orps	%xmm3,%xmm7							# merge
+		movdqa	%xmm7,%xmm1							# and replace
+	# check for +/- 0
+		xorps	%xmm7,%xmm7
+		cmpps	$0,p_x2(%rsp),%xmm7	# 0 ?.
+		movmskps	%xmm7,%r9d
+		test		$0x0f,%r9d
+		jz		.L__zn22
+
+		movdqa	%xmm7,%xmm3
+		andnps	%xmm1,%xmm3							# keep the non-error values
+		andps	.L__real_ninf(%rip),%xmm7		# ; C99 specs -inf for +-0
+		orps	%xmm3,%xmm7							# merge
+		movdqa	%xmm7,%xmm1							# and replace
+
+.L__zn22:
+	# check for NaNs
+		movaps	p_x2(%rsp),%xmm3
+		andps	.L__real_inf(%rip),%xmm3
+		cmpps	$0,.L__real_inf(%rip),%xmm3		# mask for max exponent
+
+		movdqa	p_x2(%rsp),%xmm4
+		pand	.L__real_mant(%rip),%xmm4		# mask for non-zero mantissa
+		pcmpeqd	.L__real_zero(%rip),%xmm4
+		pandn	%xmm3,%xmm4							# mask for NaNs
+		movdqa	%xmm4,%xmm2
+		movdqa	p_x2(%rsp),%xmm7			# isolate the NaNs
+		pand	%xmm4,%xmm7
+
+		pand	.L__real_qnanbit(%rip),%xmm4		# now we have a mask that will set QNaN bit
+		por		%xmm7,%xmm4							# turn SNaNs to QNaNs
+
+		movdqa	%xmm2,%xmm7
+		andnps	%xmm1,%xmm2							# keep the non-error values
+		orps	%xmm4,%xmm2							# merge
+		movdqa	%xmm2,%xmm1							# and replace
+		xorps	%xmm4,%xmm4
+
+		jmp		.L__f22
+
+	# handle only +inf	 log(+inf) = inf
+.L__log_inf2:
+		movdqa	%xmm9,%xmm7
+		andnps	%xmm1,%xmm9							# keep the non-error values
+		andps	p_x2(%rsp),%xmm7			# setup the +inf values
+		orps	%xmm9,%xmm7							# merge
+		movdqa	%xmm7,%xmm1							# and replace
+		jmp		.L__f32
+
+
+        .data
+        .align 64
+
+.L__real_zero:				.quad 0x00000000000000000	# 1.0
+					.quad 0x00000000000000000
+.L__real_one:				.quad 0x03f8000003f800000	# 1.0
+					.quad 0x03f8000003f800000
+.L__real_two:				.quad 0x04000000040000000	# 1.0
+					.quad 0x04000000040000000
+.L__real_ninf:				.quad 0x0ff800000ff800000	# -inf
+					.quad 0x0ff800000ff800000
+.L__real_inf:				.quad 0x07f8000007f800000	# +inf
+					.quad 0x07f8000007f800000
+.L__real_nan:				.quad 0x07fc000007fc00000	# NaN
+					.quad 0x07fc000007fc00000
+.L__real_ef:				.quad 0x0402DF854402DF854	# float e
+					.quad 0x0402DF854402DF854
+
+.L__real_sign:				.quad 0x08000000080000000	# sign bit
+					.quad 0x08000000080000000
+.L__real_notsign:			.quad 0x07ffFFFFF7ffFFFFF	# ^sign bit
+					.quad 0x07ffFFFFF7ffFFFFF
+.L__real_qnanbit:			.quad 0x00040000000400000	# quiet nan bit
+					.quad 0x00040000000400000
+.L__real_mant:				.quad 0x0007FFFFF007FFFFF	# mantipsa bits
+					.quad 0x0007FFFFF007FFFFF
+.L__real_3c000000:			.quad 0x03c0000003c000000	# /* 0.0078125 = 1/128 */
+					.quad 0x03c0000003c000000
+.L__mask_127:				.quad 0x00000007f0000007f	#
+					.quad 0x00000007f0000007f
+.L__mask_040:				.quad 0x00000004000000040	#
+					.quad 0x00000004000000040
+.L__mask_001:				.quad 0x00000000100000001	#
+					.quad 0x00000000100000001
+
+
+.L__real_threshold:			.quad 0x03CF5C28F3CF5C28F	# .03
+					.quad 0x03CF5C28F3CF5C28F
+
+.L__real_ca1:				.quad 0x03DAAAAAB3DAAAAAB	# 8.33333333333317923934e-02
+					.quad 0x03DAAAAAB3DAAAAAB
+.L__real_ca2:				.quad 0x03C4CCCCD3C4CCCCD	# 1.25000000037717509602e-02
+					.quad 0x03C4CCCCD3C4CCCCD
+.L__real_ca3:				.quad 0x03B1249183B124918	# 2.23213998791944806202e-03
+					.quad 0x03B1249183B124918
+.L__real_ca4:				.quad 0x039E401A639E401A6	# 4.34887777707614552256e-04
+					.quad 0x039E401A639E401A6
+.L__real_cb1:				.quad 0x03DAAAAAB3DAAAAAB	# 8.33333333333333593622e-02
+					.quad 0x03DAAAAAB3DAAAAAB
+.L__real_cb2:				.quad 0x03C4CCCCD3C4CCCCD	# 1.24999999978138668903e-02
+					.quad 0x03C4CCCCD3C4CCCCD
+.L__real_cb3:				.quad 0x03B124A123B124A12	# 2.23219810758559851206e-03
+			.quad 0x03B124A123B124A12
+.L__real_log2_lead:     .quad 0x03F3170003F317000  # 0.693115234375
+                        .quad 0x03F3170003F317000
+.L__real_log2_tail:     .quad 0x03805FDF43805FDF4  # 0.000031946183
+                        .quad 0x03805FDF43805FDF4
+.L__real_half:		.quad 0x03f0000003f000000	# 1/2
+			.quad 0x03f0000003f000000
+
+.L__real_log10e_lead:	     .quad 0x03EDE00003EDE0000	# log10e_lead  0.4335937500
+                       .quad 0x03EDE00003EDE0000
+.L__real_log10e_tail:	      .quad 0x03A37B1523A37B152  # log10e_tail  0.0007007319
+                       .quad 0x03A37B1523A37B152
+
+
+.L__mask_lower:				.quad 0x0ffff0000ffff0000	#
+					.quad 0x0ffff0000ffff0000
+.L__np_ln__table:
+	.quad	0x0000000000000000 		# 0.00000000000000000000e+00
+	.quad	0x3F8FC0A8B0FC03E4		# 1.55041813850402832031e-02
+	.quad	0x3F9F829B0E783300		# 3.07716131210327148438e-02
+	.quad	0x3FA77458F632DCFC		# 4.58095073699951171875e-02
+	.quad	0x3FAF0A30C01162A6		# 6.06245994567871093750e-02
+	.quad	0x3FB341D7961BD1D1		# 7.52233862876892089844e-02
+	.quad	0x3FB6F0D28AE56B4C		# 8.96121263504028320312e-02
+	.quad	0x3FBA926D3A4AD563		# 1.03796780109405517578e-01
+	.quad	0x3FBE27076E2AF2E6		# 1.17783010005950927734e-01
+	.quad	0x3FC0D77E7CD08E59		# 1.31576299667358398438e-01
+	.quad	0x3FC29552F81FF523		# 1.45181953907012939453e-01
+	.quad	0x3FC44D2B6CCB7D1E		# 1.58604979515075683594e-01
+	.quad	0x3FC5FF3070A793D4		# 1.71850204467773437500e-01
+	.quad	0x3FC7AB890210D909		# 1.84922337532043457031e-01
+	.quad	0x3FC9525A9CF456B4		# 1.97825729846954345703e-01
+	.quad	0x3FCAF3C94E80BFF3		# 2.10564732551574707031e-01
+	.quad	0x3FCC8FF7C79A9A22		# 2.23143517971038818359e-01
+	.quad	0x3FCE27076E2AF2E6		# 2.35566020011901855469e-01
+	.quad	0x3FCFB9186D5E3E2B		# 2.47836112976074218750e-01
+	.quad	0x3FD0A324E27390E3		# 2.59957492351531982422e-01
+	.quad	0x3FD1675CABABA60E		# 2.71933674812316894531e-01
+	.quad	0x3FD22941FBCF7966		# 2.83768117427825927734e-01
+	.quad	0x3FD2E8E2BAE11D31		# 2.95464158058166503906e-01
+	.quad	0x3FD3A64C556945EA		# 3.07025015354156494141e-01
+	.quad	0x3FD4618BC21C5EC2		# 3.18453729152679443359e-01
+	.quad	0x3FD51AAD872DF82D		# 3.29753279685974121094e-01
+	.quad	0x3FD5D1BDBF5809CA		# 3.40926527976989746094e-01
+	.quad	0x3FD686C81E9B14AF		# 3.51976394653320312500e-01
+	.quad	0x3FD739D7F6BBD007		# 3.62905442714691162109e-01
+	.quad	0x3FD7EAF83B82AFC3		# 3.73716354370117187500e-01
+	.quad	0x3FD89A3386C1425B		# 3.84411692619323730469e-01
+	.quad	0x3FD947941C2116FB		# 3.94993782043457031250e-01
+	.quad	0x3FD9F323ECBF984C		# 4.05465066432952880859e-01
+	.quad	0x3FDA9CEC9A9A084A		# 4.15827870368957519531e-01
+	.quad	0x3FDB44F77BCC8F63		# 4.26084339618682861328e-01
+	.quad	0x3FDBEB4D9DA71B7C		# 4.36236739158630371094e-01
+	.quad	0x3FDC8FF7C79A9A22		# 4.46287095546722412109e-01
+	.quad	0x3FDD32FE7E00EBD5		# 4.56237375736236572266e-01
+	.quad	0x3FDDD46A04C1C4A1		# 4.66089725494384765625e-01
+	.quad	0x3FDE744261D68788		# 4.75845873355865478516e-01
+	.quad	0x3FDF128F5FAF06ED		# 4.85507786273956298828e-01
+	.quad	0x3FDFAF588F78F31F		# 4.95077252388000488281e-01
+	.quad	0x3FE02552A5A5D0FF		# 5.04556000232696533203e-01
+	.quad	0x3FE0723E5C1CDF40		# 5.13945698738098144531e-01
+	.quad	0x3FE0BE72E4252A83		# 5.23248136043548583984e-01
+	.quad	0x3FE109F39E2D4C97		# 5.32464742660522460938e-01
+	.quad	0x3FE154C3D2F4D5EA		# 5.41597247123718261719e-01
+	.quad	0x3FE19EE6B467C96F		# 5.50647079944610595703e-01
+	.quad	0x3FE1E85F5E7040D0		# 5.59615731239318847656e-01
+	.quad	0x3FE23130D7BEBF43		# 5.68504691123962402344e-01
+	.quad	0x3FE2795E1289B11B		# 5.77315330505371093750e-01
+	.quad	0x3FE2C0E9ED448E8C		# 5.86049020290374755859e-01
+	.quad	0x3FE307D7334F10BE		# 5.94707071781158447266e-01
+	.quad	0x3FE34E289D9CE1D3		# 6.03290796279907226562e-01
+	.quad	0x3FE393E0D3562A1A		# 6.11801505088806152344e-01
+	.quad	0x3FE3D9026A7156FB		# 6.20240390300750732422e-01
+	.quad	0x3FE41D8FE84672AE		# 6.28608644008636474609e-01
+	.quad	0x3FE4618BC21C5EC2		# 6.36907458305358886719e-01
+	.quad	0x3FE4A4F85DB03EBB		# 6.45137906074523925781e-01
+	.quad	0x3FE4E7D811B75BB1		# 6.53301239013671875000e-01
+	.quad	0x3FE52A2D265BC5AB		# 6.61398470401763916016e-01
+	.quad	0x3FE56BF9D5B3F399		# 6.69430613517761230469e-01
+	.quad	0x3FE5AD404C359F2D		# 6.77398800849914550781e-01
+	.quad	0x3FE5EE02A9241675		# 6.85303986072540283203e-01
+	.quad	0x3FE62E42FEFA39EF		# 6.93147122859954833984e-01
+	.quad 0					# for alignment
+
+.L__np_ln_lead_table:
+    .long 0x00000000  # 0.000000000000 0
+    .long 0x3C7E0000  # 0.015502929688 1
+    .long 0x3CFC1000  # 0.030769348145 2
+    .long 0x3D3BA000  # 0.045806884766 3
+    .long 0x3D785000  # 0.060623168945 4
+    .long 0x3D9A0000  # 0.075195312500 5
+    .long 0x3DB78000  # 0.089599609375 6
+    .long 0x3DD49000  # 0.103790283203 7
+    .long 0x3DF13000  # 0.117767333984 8
+    .long 0x3E06B000  # 0.131530761719 9
+    .long 0x3E14A000  # 0.145141601563 10
+    .long 0x3E226000  # 0.158569335938 11
+    .long 0x3E2FF000  # 0.171813964844 12
+    .long 0x3E3D5000  # 0.184875488281 13
+    .long 0x3E4A9000  # 0.197814941406 14
+    .long 0x3E579000  # 0.210510253906 15
+    .long 0x3E647000  # 0.223083496094 16
+    .long 0x3E713000  # 0.235534667969 17
+    .long 0x3E7DC000  # 0.247802734375 18
+    .long 0x3E851000  # 0.259887695313 19
+    .long 0x3E8B3000  # 0.271850585938 20
+    .long 0x3E914000  # 0.283691406250 21
+    .long 0x3E974000  # 0.295410156250 22
+    .long 0x3E9D3000  # 0.307006835938 23
+    .long 0x3EA30000  # 0.318359375000 24
+    .long 0x3EA8D000  # 0.329711914063 25
+    .long 0x3EAE8000  # 0.340820312500 26
+    .long 0x3EB43000  # 0.351928710938 27
+    .long 0x3EB9C000  # 0.362792968750 28
+    .long 0x3EBF5000  # 0.373657226563 29
+    .long 0x3EC4D000  # 0.384399414063 30
+    .long 0x3ECA3000  # 0.394897460938 31
+    .long 0x3ECF9000  # 0.405395507813 32
+    .long 0x3ED4E000  # 0.415771484375 33
+    .long 0x3EDA2000  # 0.426025390625 34
+    .long 0x3EDF5000  # 0.436157226563 35
+    .long 0x3EE47000  # 0.446166992188 36
+    .long 0x3EE99000  # 0.456176757813 37
+    .long 0x3EEEA000  # 0.466064453125 38
+    .long 0x3EF3A000  # 0.475830078125 39
+    .long 0x3EF89000  # 0.485473632813 40
+    .long 0x3EFD7000  # 0.494995117188 41
+    .long 0x3F012000  # 0.504394531250 42
+    .long 0x3F039000  # 0.513916015625 43
+    .long 0x3F05F000  # 0.523193359375 44
+    .long 0x3F084000  # 0.532226562500 45
+    .long 0x3F0AA000  # 0.541503906250 46
+    .long 0x3F0CF000  # 0.550537109375 47
+    .long 0x3F0F4000  # 0.559570312500 48
+    .long 0x3F118000  # 0.568359375000 49
+    .long 0x3F13C000  # 0.577148437500 50
+    .long 0x3F160000  # 0.585937500000 51
+    .long 0x3F183000  # 0.594482421875 52
+    .long 0x3F1A7000  # 0.603271484375 53
+    .long 0x3F1C9000  # 0.611572265625 54
+    .long 0x3F1EC000  # 0.620117187500 55
+    .long 0x3F20E000  # 0.628417968750 56
+    .long 0x3F230000  # 0.636718750000 57
+    .long 0x3F252000  # 0.645019531250 58
+    .long 0x3F273000  # 0.653076171875 59
+    .long 0x3F295000  # 0.661376953125 60
+    .long 0x3F2B5000  # 0.669189453125 61
+    .long 0x3F2D6000  # 0.677246093750 62
+    .long 0x3F2F7000  # 0.685302734375 63
+    .long 0x3F317000  # 0.693115234375 64
+    .long 0					# for alignment
+
+.L__np_ln_tail_table:
+    .long 0x00000000  # 0.000000000000 0
+    .long 0x35A8B0FC  # 0.000001256848 1
+    .long 0x361B0E78  # 0.000002310522 2
+    .long 0x3631EC66  # 0.000002651266 3
+    .long 0x35C30046  # 0.000001452871 4
+    .long 0x37EBCB0E  # 0.000028108738 5
+    .long 0x37528AE5  # 0.000012549314 6
+    .long 0x36DA7496  # 0.000006510479 7
+    .long 0x3783B715  # 0.000015701671 8
+    .long 0x383F3E68  # 0.000045596069 9
+    .long 0x38297C10  # 0.000040408282 10
+    .long 0x3815B666  # 0.000035694240 11
+    .long 0x38183854  # 0.000036292084 12
+    .long 0x38448108  # 0.000046850211 13
+    .long 0x373539E9  # 0.000010801924 14
+    .long 0x3864A740  # 0.000054515200 15
+    .long 0x387BE3CD  # 0.000060055219 16
+    .long 0x3803B715  # 0.000031403342 17
+    .long 0x380C36AF  # 0.000033429529 18
+    .long 0x3892713A  # 0.000069829126 19
+    .long 0x38AE55D6  # 0.000083129547 20
+    .long 0x38A0FDE8  # 0.000076766883 21
+    .long 0x3862BAE1  # 0.000054056643 22
+    .long 0x3798AAD3  # 0.000018199358 23
+    .long 0x38C5E10E  # 0.000094356117 24
+    .long 0x382D872E  # 0.000041372310 25
+    .long 0x38DEDFAC  # 0.000106274470 26
+    .long 0x38481E9B  # 0.000047712219 27
+    .long 0x38EBFB5E  # 0.000112524940 28
+    .long 0x38783B83  # 0.000059183232 29
+    .long 0x374E1B05  # 0.000012284848 30
+    .long 0x38CA0E11  # 0.000096347307 31
+    .long 0x3891F660  # 0.000069600297 32
+    .long 0x386C9A9A  # 0.000056410769 33
+    .long 0x38777BCD  # 0.000059004688 34
+    .long 0x38A6CED4  # 0.000079540216 35
+    .long 0x38FBE3CD  # 0.000120110439 36
+    .long 0x387E7E01  # 0.000060675669 37
+    .long 0x37D40984  # 0.000025276800 38
+    .long 0x3784C3AD  # 0.000015826745 39
+    .long 0x380F5FAF  # 0.000034182969 40
+    .long 0x38AC47BC  # 0.000082149607 41
+    .long 0x392952D3  # 0.000161479504 42
+    .long 0x37F97073  # 0.000029735476 43
+    .long 0x3865C84A  # 0.000054784388 44
+    .long 0x3979CF17  # 0.000238236375 45
+    .long 0x38C3D2F5  # 0.000093376184 46
+    .long 0x38E6B468  # 0.000110008579 47
+    .long 0x383EBCE1  # 0.000045475437 48
+    .long 0x39186BDF  # 0.000145360347 49
+    .long 0x392F0945  # 0.000166927537 50
+    .long 0x38E9ED45  # 0.000111545007 51
+    .long 0x396B99A8  # 0.000224685878 52
+    .long 0x37A27674  # 0.000019367064 53
+    .long 0x397069AB  # 0.000229275480 54
+    .long 0x39013539  # 0.000123222257 55
+    .long 0x3947F423  # 0.000190690669 56
+    .long 0x3945E10E  # 0.000188712234 57
+    .long 0x38F85DB0  # 0.000118430122 58
+    .long 0x396C08DC  # 0.000225100142 59
+    .long 0x37B4996F  # 0.000021529120 60
+    .long 0x397CEADA  # 0.000241200818 61
+    .long 0x3920261B  # 0.000152729845 62
+    .long 0x35AA4906  # 0.000001268724 63
+    .long 0x3805FDF4  # 0.000031946183 64
+    .long 0					# for alignment
+
+
diff --git a/src/gas/vrs8log2f.S b/src/gas/vrs8log2f.S
new file mode 100644
index 0000000..d1028b0
--- /dev/null
+++ b/src/gas/vrs8log2f.S
@@ -0,0 +1,956 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrs8log2f.s
+#
+# A vector implementation of the logf libm function.
+#  This routine implemented in single precision.  It is slightly
+#  less accurate than the double precision version, but it will
+#  be better for vectorizing.
+#
+# Prototype:
+#
+#    __m128,__m128 __vrs8_log2f(__m128 x1, __m128 x2);
+#
+#   Computes the natural log of x for eight packed single values.
+#   Places the results into xmm0 and xmm1.
+#   Returns proper C99 values, but may not raise status flags properly.
+#   Less than 1 ulp of error.
+#
+# This array version is basically a unrolling of the by4 scalar single
+# routine.  The second set of operations is performed by the indented
+# instructions interleaved into the first set.
+# The scheduling is done by trial and error.  The resulting code represents
+# the best time of many variations.  It would seem more interleaving could
+# be done, as there is a long stretch of the second computation that is not
+# interleaved.  But moving any of this code forward makes the routine
+# slower.
+#
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+    .text
+    .align 16
+    .p2align 4,,15
+
+# define local variable storage offsets
+.equ	p_x,0			# save x
+.equ	p_idx,0x010		# xmmword index
+.equ	p_z1,0x020		# xmmword index
+.equ	p_q,0x030		# xmmword index
+.equ	p_corr,0x040		# xmmword index
+.equ	p_omask,0x050		# xmmword index
+.equ	save_xmm6,0x060		#
+.equ	save_rbx,0x070		#
+.equ	save_xmm7,0x080		#
+.equ	save_xmm8,0x090		#
+.equ	save_xmm9,0x0a0		#
+.equ	save_xmm10,0x0b0		#
+.equ	save_xmm11,0x0c0		#
+.equ	save_xmm12,0x0d0		#
+.equ	save_xmm13,0x0d0		#
+.equ	p_x2,0x0100		# save x
+.equ	p_idx2,0x0110		# xmmword index
+.equ	p_z12,0x0120		# xmmword index
+.equ	p_q2,0x0130		# xmmword index
+
+.equ	stack_size,0x0168
+
+
+
+.globl __vrs8_log2f
+    .type   __vrs8_log2f,@function
+__vrs8_log2f:
+	sub		$stack_size,%rsp
+	mov		%rbx,save_rbx(%rsp)	# save rbx
+
+# check e as a special case
+	movdqa	%xmm0,p_x(%rsp)	# save x
+		movdqa	%xmm1,p_x2(%rsp)	# save x
+#	movdqa	%xmm0,%xmm2
+#	cmpps	$0,.L__real_ef(%rip),%xmm2
+#	movmskps	%xmm2,%r9d
+
+		movdqa	%xmm1,%xmm12
+		movdqa	%xmm1,%xmm9
+		movaps	%xmm1,%xmm7
+
+#
+# compute the index into the log tables
+#
+	movdqa	%xmm0,%xmm3
+	movaps	%xmm0,%xmm1
+	psrld	$23,%xmm3
+
+	#
+	# compute the index into the log tables
+	#
+		psrld	$23,%xmm9
+		subps	.L__real_one(%rip),%xmm7
+		psubd	.L__mask_127(%rip),%xmm9
+	subps	.L__real_one(%rip),%xmm1
+	psubd	.L__mask_127(%rip),%xmm3
+		cvtdq2ps	%xmm9,%xmm13			# xexp
+
+		movdqa	%xmm12,%xmm9
+		pand	.L__real_mant(%rip),%xmm9
+		xor		%r8,%r8
+		movdqa	%xmm9,%xmm8
+		movaps	.L__real_half(%rip),%xmm11							# .5
+	cvtdq2ps	%xmm3,%xmm6			# xexp
+
+	movdqa	%xmm0,%xmm3
+	pand	.L__real_mant(%rip),%xmm3
+	xor		%r8,%r8
+	movdqa	%xmm3,%xmm2
+	movaps	.L__real_half(%rip),%xmm5							# .5
+
+#/* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+	psrld	$16,%xmm3
+	lea		.L__np_ln_lead_table(%rip),%rdx
+	movdqa	%xmm3,%xmm4
+		psrld	$16,%xmm9
+		movdqa	%xmm9,%xmm10
+		psrld	$1,%xmm9
+	psrld	$1,%xmm3
+	paddd	.L__mask_040(%rip),%xmm3
+	pand	.L__mask_001(%rip),%xmm4
+	paddd	%xmm4,%xmm3
+	cvtdq2ps	%xmm3,%xmm1
+	#/* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+		paddd	.L__mask_040(%rip),%xmm9
+		pand	.L__mask_001(%rip),%xmm10
+		paddd	%xmm10,%xmm9
+		cvtdq2ps	%xmm9,%xmm7
+	packssdw	%xmm3,%xmm3
+	movq	%xmm3,p_idx(%rsp)
+		packssdw	%xmm9,%xmm9
+		movq	%xmm9,p_idx2(%rsp)
+
+
+# reduce and get u
+	movdqa	%xmm0,%xmm3
+	orps		.L__real_half(%rip),%xmm2
+
+
+	mulps	.L__real_3c000000(%rip),%xmm1				# f1 = index/128
+	# reduce and get u
+
+
+	subps	%xmm1,%xmm2											# f2 = f - f1
+	mulps	%xmm2,%xmm5
+	addps	%xmm5,%xmm1
+
+	divps	%xmm1,%xmm2				# u
+
+		movdqa	%xmm12,%xmm9
+		orps		.L__real_half(%rip),%xmm8
+
+
+		mulps	.L__real_3c000000(%rip),%xmm7				# f1 = index/128
+		subps	%xmm7,%xmm8											# f2 = f - f1
+		mulps	%xmm8,%xmm11
+		addps	%xmm11,%xmm7
+
+
+	mov		p_idx(%rsp),%rcx 			# get the indexes
+	mov		%cx,%r8w
+	ror		$16,%rcx
+	mov		-256(%rdx,%r8,4),%eax		# get the f1 value
+
+	mov		%cx,%r8w
+	ror		$16,%rcx
+	mov		-256(%rdx,%r8,4),%ebx		# get the f1 value
+	shl		$32,%rbx
+	or		%rbx,%rax
+	mov		 %rax,p_z1(%rsp) 			# save the f1 values
+
+	mov		%cx,%r8w
+	ror		$16,%rcx
+	mov		-256(%rdx,%r8,4),%eax		# get the f1 value
+
+	mov		%cx,%r8w
+	ror		$16,%rcx
+	or		-256(%rdx,%r8,4),%ebx		# get the f1 value
+	shl		$32,%rbx
+	or		%rbx,%rax
+	mov		 %rax,p_z1+8(%rsp) 			# save the f1 value
+		divps	%xmm7,%xmm8				# u
+		lea		.L__np_ln_lead_table(%rip),%rdx
+		mov		p_idx2(%rsp),%rcx 			# get the indexes
+		mov		%cx,%r8w
+		ror		$16,%rcx
+		mov		-256(%rdx,%r8,4),%eax		# get the f1 value
+
+		mov		%cx,%r8w
+		ror		$16,%rcx
+		mov		-256(%rdx,%r8,4),%ebx		# get the f1 value
+		shl		$32,%rbx
+		or		%rbx,%rax
+		mov		 %rax,p_z12(%rsp) 			# save the f1 values
+
+		mov		%cx,%r8w
+		ror		$16,%rcx
+		mov		-256(%rdx,%r8,4),%eax		# get the f1 value
+
+		mov		%cx,%r8w
+		ror		$16,%rcx
+		or		-256(%rdx,%r8,4),%ebx		# get the f1 value
+		shl		$32,%rbx
+		or		%rbx,%rax
+		mov		 %rax,p_z12+8(%rsp) 			# save the f1 value
+# solve for ln(1+u)
+	movaps	%xmm2,%xmm1				# u
+	mulps	%xmm2,%xmm2				# u^2
+	movaps	%xmm2,%xmm5
+	movaps	.L__real_cb3(%rip),%xmm3
+	mulps	%xmm2,%xmm3				#Cu2
+	mulps	%xmm1,%xmm5				# u^3
+	addps	.L__real_cb2(%rip),%xmm3 #B+Cu2
+	movaps	%xmm2,%xmm4
+	mulps	%xmm5,%xmm4				# u^5
+	movaps	.L__real_log2e_lead(%rip),%xmm2
+
+	mulps	.L__real_cb1(%rip),%xmm5 #Au3
+	addps	%xmm5,%xmm1				# u+Au3
+	mulps	%xmm3,%xmm4				# u5(B+Cu2)
+	movaps	.L__real_log2e_tail(%rip),%xmm3
+	lea		.L__np_ln_tail_table(%rip),%rdx
+	addps	%xmm4,%xmm1				# poly
+
+# recombine
+	mov		p_idx(%rsp),%rcx 			# get the indexes
+	mov		%cx,%r8w
+	shr		$16,%rcx
+	mov		-256(%rdx,%r8,4),%eax		# get the f2 value
+
+	mov		%cx,%r8w
+	shr		$16,%rcx
+	or		-256(%rdx,%r8,4),%ebx		# get the f2 value
+	shl		$32,%rbx
+	or		%rbx,%rax
+	mov		 %rax,p_q(%rsp) 			# save the f2 value
+
+	mov		%cx,%r8w
+	shr		$16,%rcx
+	mov		-256(%rdx,%r8,4),%eax		# get the f2 value
+
+	mov		%cx,%r8w
+	mov		-256(%rdx,%r8,4),%ebx		# get the f2 value
+	shl		$32,%rbx
+	or		%rbx,%rax
+	mov		 %rax,p_q+8(%rsp) 			# save the f2 value
+
+	addps	p_q(%rsp),%xmm1 #z2	+=q
+	movaps	%xmm1,%xmm4	#z2 copy
+	movaps	p_z1(%rsp),%xmm0			# z1  values
+	movaps	%xmm0,%xmm5	#z1 copy
+
+	mulps	%xmm2,%xmm5	#z1*log2e_lead
+	mulps	%xmm2,%xmm1	#z2*log2e_lead
+	mulps	%xmm3,%xmm4	#z2*log2e_tail
+	mulps	%xmm3,%xmm0	#z1*log2e_tail
+	addps	%xmm6,%xmm5	#r1 = z1*log2e_lead + xexp
+	addps	%xmm4,%xmm0	#z1*log2e_tail + z2*log2e_tail
+	addps	%xmm1,%xmm0	#r2
+#return r1+r2
+	addps 	%xmm5,%xmm0	# r1+ r2
+
+
+
+# check for e
+#	test		$0x0f,%r9d
+#	jnz			.L__vlogf_e
+.L__f1:
+
+# check for negative numbers or zero
+	xorps	%xmm1,%xmm1
+	cmpps	$1,p_x(%rsp),%xmm1	# 0 greater than =?. catches NaNs also.
+	movmskps	%xmm1,%r9d
+	cmp		$0x0f,%r9d
+	jnz		.L__z_or_neg
+
+.L__f2:
+##  if +inf
+	movaps	p_x(%rsp),%xmm3
+	cmpps	$0,.L__real_inf(%rip),%xmm3
+	movmskps	%xmm3,%r9d
+	test		$0x0f,%r9d
+	jnz		.L__log_inf
+.L__f3:
+
+	movaps	p_x(%rsp),%xmm3
+	subps	.L__real_one(%rip),%xmm3
+	andps	.L__real_notsign(%rip),%xmm3
+	cmpps	$2,.L__real_threshold(%rip),%xmm3
+	movmskps	%xmm3,%r9d
+	test	$0x0f,%r9d
+	jnz		.L__near_one
+.L__f4:
+
+# finish the second set of calculations
+
+	# solve for ln(1+u)
+		movaps	%xmm8,%xmm7				# u
+		mulps	%xmm8,%xmm8				# u^2
+		movaps	%xmm8,%xmm11
+
+		movaps	.L__real_cb3(%rip),%xmm9
+		mulps	%xmm8,%xmm9				#Cu2
+		mulps	%xmm7,%xmm11				# u^3
+		addps	.L__real_cb2(%rip),%xmm9 #B+Cu2
+		movaps	%xmm8,%xmm10
+		mulps	%xmm11,%xmm10				# u^5
+		movaps	.L__real_log2e_lead(%rip),%xmm8
+
+		mulps	.L__real_cb1(%rip),%xmm11 #Au3
+		addps	%xmm11,%xmm7				# u+Au3
+		mulps	%xmm9,%xmm10				# u5(B+Cu2)
+		movaps	.L__real_log2e_tail(%rip),%xmm9
+		addps	%xmm10,%xmm7				# poly
+
+
+	# recombine
+		lea		.L__np_ln_tail_table(%rip),%rdx
+		mov		p_idx2(%rsp),%rcx 			# get the indexes
+		mov		%cx,%r8w
+		shr		$16,%rcx
+		mov		-256(%rdx,%r8,4),%eax		# get the f2 value
+
+		mov		%cx,%r8w
+		shr		$16,%rcx
+		or		-256(%rdx,%r8,4),%ebx		# get the f2 value
+		shl		$32,%rbx
+		or		%rbx,%rax
+		mov		 %rax,p_q2(%rsp) 			# save the f2 value
+
+		mov		%cx,%r8w
+		shr		$16,%rcx
+		mov		-256(%rdx,%r8,4),%eax		# get the f2 value
+
+		mov		%cx,%r8w
+		mov		-256(%rdx,%r8,4),%ebx		# get the f2 value
+		shl		$32,%rbx
+		or		%rbx,%rax
+		mov		 %rax,p_q2+8(%rsp) 			# save the f2 value
+		addps	p_q2(%rsp),%xmm7 #z2	+=q
+		movaps	%xmm7,%xmm10	#z2 copy
+		movaps	p_z12(%rsp),%xmm1			# z1  values
+		movaps	%xmm1,%xmm11	#z1 copy
+
+		mulps	%xmm8,%xmm11	#z1*log2e_lead
+		mulps	%xmm8,%xmm7	#z2*log2e_lead
+		mulps	%xmm9,%xmm10	#z2*log2e_tail
+		mulps	%xmm9,%xmm1	#z1*log2e_tail
+		addps	%xmm13,%xmm11	#r1 = z1*log2e_lead + xexp
+		addps	%xmm10,%xmm1	#z1*log2e_tail + z2*log2e_tail
+		addps	%xmm7,%xmm1	#r2
+		#return r1+r2
+		addps 	%xmm11,%xmm1	# r1+ r2
+
+	# check e as a special case
+#		movaps	p_x2(%rsp),%xmm10
+#		cmpps	$0,.L__real_ef(%rip),%xmm10
+#		movmskps	%xmm10,%r9d
+	# check for e
+#		test		$0x0f,%r9d
+#		jnz			.L__vlogf_e2
+.L__f12:
+
+	# check for negative numbers or zero
+		xorps	%xmm7,%xmm7
+		cmpps	$1,p_x2(%rsp),%xmm7	# 0 greater than =?. catches NaNs also.
+		movmskps	%xmm7,%r9d
+		cmp		$0x0f,%r9d
+		jnz		.L__z_or_neg2
+
+.L__f22:
+	##  if +inf
+		movaps	p_x2(%rsp),%xmm9
+		cmpps	$0,.L__real_inf(%rip),%xmm9
+		movmskps	%xmm9,%r9d
+		test		$0x0f,%r9d
+		jnz		.L__log_inf2
+.L__f32:
+
+		movaps	p_x2(%rsp),%xmm9
+		subps	.L__real_one(%rip),%xmm9
+		andps	.L__real_notsign(%rip),%xmm9
+		cmpps	$2,.L__real_threshold(%rip),%xmm9
+		movmskps	%xmm9,%r9d
+		test	$0x0f,%r9d
+		jnz		.L__near_one2
+.L__f42:
+
+
+.L__finish:
+	mov		save_rbx(%rsp),%rbx		# restore rbx
+	add		$stack_size,%rsp
+	ret
+
+.L__vlogf_e:
+	movdqa	p_x(%rsp),%xmm2
+	cmpps	$0,.L__real_ef(%rip),%xmm2
+	movdqa	%xmm2,%xmm3
+	andnps	%xmm0,%xmm3							# keep the non-e values
+	andps	.L__real_one(%rip),%xmm2			# setup the 1 values
+	orps	%xmm3,%xmm2							# merge
+	movdqa	%xmm2,%xmm0							# and replace
+	jmp		.L__f1
+
+.L__vlogf_e2:
+		movdqa	p_x2(%rsp),%xmm2
+		cmpps	$0,.L__real_ef(%rip),%xmm2
+		movdqa	%xmm2,%xmm3
+		andnps	%xmm1,%xmm3							# keep the non-e values
+		andps	.L__real_one(%rip),%xmm2			# setup the 1 values
+		orps	%xmm3,%xmm2							# merge
+		movdqa	%xmm2,%xmm1							# and replace
+		jmp		.L__f12
+
+	.align	16
+.L__near_one:
+# saves 10 cycles
+#      r = x - 1.0;
+	movdqa	%xmm3,p_omask(%rsp)	# save ones mask
+	movaps	p_x(%rsp),%xmm3
+	movaps	.L__real_two(%rip),%xmm2
+	subps	.L__real_one(%rip),%xmm3	   # r
+#      u          = r / (2.0 + r);
+	addps	%xmm3,%xmm2
+	movaps	%xmm3,%xmm1
+	divps	%xmm2,%xmm1		# u
+	movaps	.L__real_ca4(%rip),%xmm4	  #D
+	movaps	.L__real_ca3(%rip),%xmm5	  #C
+#      correction = r * u;
+	movaps	%xmm3,%xmm6
+	mulps	%xmm1,%xmm6		# correction
+	movdqa	%xmm6,p_corr(%rsp)	# save correction
+#      u          = u + u;
+	addps	%xmm1,%xmm1		#u
+	movaps	%xmm1,%xmm2
+	mulps	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulps	%xmm1,%xmm5		# Cu
+	movaps	%xmm1,%xmm6
+	mulps	%xmm2,%xmm6		# u^3
+	mulps	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulps	%xmm6,%xmm4		#Du^3
+
+	addps	.L__real_ca1(%rip),%xmm2	# +A
+	movaps	%xmm6,%xmm1
+	mulps	%xmm1,%xmm1		# u^6
+	addps	%xmm4,%xmm5		#Cu+Du3
+
+	mulps	%xmm6,%xmm2		#u3(A+Bu2)
+	mulps	%xmm5,%xmm1		#u6(Cu+Du3)
+	addps	%xmm1,%xmm2
+	subps	p_corr(%rsp),%xmm2		# -correction
+
+#   loge to log2
+	movaps  %xmm3,%xmm5 	#r1=r
+	pand 	.L__mask_lower(%rip),%xmm5
+	subps	%xmm5,%xmm3
+	addps	%xmm3,%xmm2	#r2 = r2 + (r-r1)
+
+	movaps	%xmm5,%xmm3
+	movaps	%xmm2,%xmm1
+
+	mulps 	.L__real_log2e_tail(%rip),%xmm2
+	mulps 	.L__real_log2e_tail(%rip),%xmm3
+	mulps 	.L__real_log2e_lead(%rip),%xmm1
+	mulps 	.L__real_log2e_lead(%rip),%xmm5
+	addps 	%xmm2,%xmm3
+	addps 	%xmm1,%xmm3
+	addps	%xmm5,%xmm3
+
+#      return r + r2;
+#	addps	%xmm2,%xmm3
+
+	movdqa	p_omask(%rsp),%xmm6
+	movdqa	%xmm6,%xmm2
+	andnps	%xmm0,%xmm6					# keep the non-nearone values
+	andps	%xmm3,%xmm2					# setup the nearone values
+	orps	%xmm6,%xmm2					# merge
+	movdqa	%xmm2,%xmm0					# and replace
+
+	jmp		.L__f4
+
+
+	.align	16
+.L__near_one2:
+# saves 10 cycles
+#      r = x - 1.0;
+		movdqa	%xmm9,p_omask(%rsp)	# save ones mask
+		movaps	p_x2(%rsp),%xmm3
+		movaps	.L__real_two(%rip),%xmm2
+		subps	.L__real_one(%rip),%xmm3	   # r
+	#      u          = r / (2.0 + r);
+		addps	%xmm3,%xmm2
+		movaps	%xmm3,%xmm7
+		divps	%xmm2,%xmm7		# u
+		movaps	.L__real_ca4(%rip),%xmm4	  #D
+		movaps	.L__real_ca3(%rip),%xmm5	  #C
+	#      correction = r * u;
+		movaps	%xmm3,%xmm6
+		mulps	%xmm7,%xmm6		# correction
+		movdqa	%xmm6,p_corr(%rsp)	# save correction
+	#      u          = u + u;
+		addps	%xmm7,%xmm7		#u
+		movaps	%xmm7,%xmm2
+		mulps	%xmm2,%xmm2		#v =u^2
+	#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+		mulps	%xmm7,%xmm5		# Cu
+		movaps	%xmm7,%xmm6
+		mulps	%xmm2,%xmm6		# u^3
+		mulps	.L__real_ca2(%rip),%xmm2	#Bu^2
+		mulps	%xmm6,%xmm4		#Du^3
+
+		addps	.L__real_ca1(%rip),%xmm2	# +A
+		movaps	%xmm6,%xmm7
+		mulps	%xmm7,%xmm7		# u^6
+		addps	%xmm4,%xmm5		#Cu+Du3
+
+		mulps	%xmm6,%xmm2		#u3(A+Bu2)
+		mulps	%xmm5,%xmm7		#u6(Cu+Du3)
+		addps	%xmm7,%xmm2
+		subps	p_corr(%rsp),%xmm2		# -correction
+
+# loge to log2
+		movaps  %xmm3,%xmm5 	#r1=r
+		pand 	.L__mask_lower(%rip),%xmm5
+		subps	%xmm5,%xmm3
+		addps	%xmm3,%xmm2 #r2 = r2 + (r-r1)
+
+		movaps	%xmm5,%xmm3
+		movaps	%xmm2,%xmm7
+
+		mulps 	.L__real_log2e_tail(%rip),%xmm2
+		mulps 	.L__real_log2e_tail(%rip),%xmm3
+		mulps 	.L__real_log2e_lead(%rip),%xmm7
+		mulps 	.L__real_log2e_lead(%rip),%xmm5
+		addps 	%xmm2,%xmm3
+		addps 	%xmm7,%xmm3
+		addps	%xmm5,%xmm3
+
+	#      return r + r2;
+	#	addps	%xmm2,%xmm3
+
+		movdqa	p_omask(%rsp),%xmm6
+		movdqa	%xmm6,%xmm2
+		andnps	%xmm1,%xmm6					# keep the non-nearone values
+		andps	%xmm3,%xmm2					# setup the nearone values
+		orps	%xmm6,%xmm2					# merge
+		movdqa	%xmm2,%xmm1					# and replace
+
+		jmp		.L__f42
+
+# we have a zero, a negative number, or both.
+# the mask is already in .LNaNs,%xmm1 are also picked up here, along with -inf.
+.L__z_or_neg:
+# deal with negatives first
+	movdqa	%xmm1,%xmm3
+	andps	%xmm0,%xmm3							# keep the non-error values
+	andnps	.L__real_nan(%rip),%xmm1			# setup the nan values
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+# check for +/- 0
+	xorps	%xmm1,%xmm1
+	cmpps	$0,p_x(%rsp),%xmm1	# 0 ?.
+	movmskps	%xmm1,%r9d
+	test		$0x0f,%r9d
+	jz		.L__zn2
+
+	movdqa	%xmm1,%xmm3
+	andnps	%xmm0,%xmm3							# keep the non-error values
+	andps	.L__real_ninf(%rip),%xmm1		# ; C99 specs -inf for +-0
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+
+.L__zn2:
+# check for NaNs
+	movaps	p_x(%rsp),%xmm3
+	andps	.L__real_inf(%rip),%xmm3
+	cmpps	$0,.L__real_inf(%rip),%xmm3		# mask for max exponent
+
+	movdqa	p_x(%rsp),%xmm4
+	pand	.L__real_mant(%rip),%xmm4		# mask for non-zero mantissa
+	pcmpeqd	.L__real_zero(%rip),%xmm4
+	pandn	%xmm3,%xmm4							# mask for NaNs
+	movdqa	%xmm4,%xmm2
+	movdqa	p_x(%rsp),%xmm1			# isolate the NaNs
+	pand	%xmm4,%xmm1
+
+	pand	.L__real_qnanbit(%rip),%xmm4		# now we have a mask that will set QNaN bit
+	por		%xmm1,%xmm4							# turn SNaNs to QNaNs
+
+	movdqa	%xmm2,%xmm1
+	andnps	%xmm0,%xmm2							# keep the non-error values
+	orps	%xmm4,%xmm2							# merge
+	movdqa	%xmm2,%xmm0							# and replace
+	xorps	%xmm4,%xmm4
+
+	jmp		.L__f2
+
+# handle only +inf	 log(+inf) = inf
+.L__log_inf:
+	movdqa	%xmm3,%xmm1
+	andnps	%xmm0,%xmm3							# keep the non-error values
+	andps	p_x(%rsp),%xmm1			# setup the +inf values
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+	jmp		.L__f3
+
+
+.L__z_or_neg2:
+	# deal with negatives first
+		movdqa	%xmm7,%xmm3
+		andps	%xmm1,%xmm3							# keep the non-error values
+		andnps	.L__real_nan(%rip),%xmm7			# setup the nan values
+		orps	%xmm3,%xmm7							# merge
+		movdqa	%xmm7,%xmm1							# and replace
+	# check for +/- 0
+		xorps	%xmm7,%xmm7
+		cmpps	$0,p_x2(%rsp),%xmm7	# 0 ?.
+		movmskps	%xmm7,%r9d
+		test		$0x0f,%r9d
+		jz		.L__zn22
+
+		movdqa	%xmm7,%xmm3
+		andnps	%xmm1,%xmm3							# keep the non-error values
+		andps	.L__real_ninf(%rip),%xmm7		# ; C99 specs -inf for +-0
+		orps	%xmm3,%xmm7							# merge
+		movdqa	%xmm7,%xmm1							# and replace
+
+.L__zn22:
+	# check for NaNs
+		movaps	p_x2(%rsp),%xmm3
+		andps	.L__real_inf(%rip),%xmm3
+		cmpps	$0,.L__real_inf(%rip),%xmm3		# mask for max exponent
+
+		movdqa	p_x2(%rsp),%xmm4
+		pand	.L__real_mant(%rip),%xmm4		# mask for non-zero mantissa
+		pcmpeqd	.L__real_zero(%rip),%xmm4
+		pandn	%xmm3,%xmm4							# mask for NaNs
+		movdqa	%xmm4,%xmm2
+		movdqa	p_x2(%rsp),%xmm7			# isolate the NaNs
+		pand	%xmm4,%xmm7
+
+		pand	.L__real_qnanbit(%rip),%xmm4		# now we have a mask that will set QNaN bit
+		por		%xmm7,%xmm4							# turn SNaNs to QNaNs
+
+		movdqa	%xmm2,%xmm7
+		andnps	%xmm1,%xmm2							# keep the non-error values
+		orps	%xmm4,%xmm2							# merge
+		movdqa	%xmm2,%xmm1							# and replace
+		xorps	%xmm4,%xmm4
+
+		jmp		.L__f22
+
+	# handle only +inf	 log(+inf) = inf
+.L__log_inf2:
+		movdqa	%xmm9,%xmm7
+		andnps	%xmm1,%xmm9							# keep the non-error values
+		andps	p_x2(%rsp),%xmm7			# setup the +inf values
+		orps	%xmm9,%xmm7							# merge
+		movdqa	%xmm7,%xmm1							# and replace
+		jmp		.L__f32
+
+
+        .data
+        .align 64
+
+.L__real_zero:				.quad 0x00000000000000000	# 1.0
+					.quad 0x00000000000000000
+.L__real_one:				.quad 0x03f8000003f800000	# 1.0
+					.quad 0x03f8000003f800000
+.L__real_two:				.quad 0x04000000040000000	# 1.0
+					.quad 0x04000000040000000
+.L__real_ninf:				.quad 0x0ff800000ff800000	# -inf
+					.quad 0x0ff800000ff800000
+.L__real_inf:				.quad 0x07f8000007f800000	# +inf
+					.quad 0x07f8000007f800000
+.L__real_nan:				.quad 0x07fc000007fc00000	# NaN
+					.quad 0x07fc000007fc00000
+.L__real_ef:				.quad 0x0402DF854402DF854	# float e
+					.quad 0x0402DF854402DF854
+
+.L__real_sign:				.quad 0x08000000080000000	# sign bit
+					.quad 0x08000000080000000
+.L__real_notsign:			.quad 0x07ffFFFFF7ffFFFFF	# ^sign bit
+					.quad 0x07ffFFFFF7ffFFFFF
+.L__real_qnanbit:			.quad 0x00040000000400000	# quiet nan bit
+					.quad 0x00040000000400000
+.L__real_mant:				.quad 0x0007FFFFF007FFFFF	# mantipsa bits
+					.quad 0x0007FFFFF007FFFFF
+.L__real_3c000000:			.quad 0x03c0000003c000000	# /* 0.0078125 = 1/128 */
+					.quad 0x03c0000003c000000
+.L__mask_127:				.quad 0x00000007f0000007f	#
+					.quad 0x00000007f0000007f
+.L__mask_040:				.quad 0x00000004000000040	#
+					.quad 0x00000004000000040
+.L__mask_001:				.quad 0x00000000100000001	#
+					.quad 0x00000000100000001
+
+
+.L__real_threshold:			.quad 0x03CF5C28F3CF5C28F	# .03
+					.quad 0x03CF5C28F3CF5C28F
+
+.L__real_ca1:				.quad 0x03DAAAAAB3DAAAAAB	# 8.33333333333317923934e-02
+					.quad 0x03DAAAAAB3DAAAAAB
+.L__real_ca2:				.quad 0x03C4CCCCD3C4CCCCD	# 1.25000000037717509602e-02
+					.quad 0x03C4CCCCD3C4CCCCD
+.L__real_ca3:				.quad 0x03B1249183B124918	# 2.23213998791944806202e-03
+					.quad 0x03B1249183B124918
+.L__real_ca4:				.quad 0x039E401A639E401A6	# 4.34887777707614552256e-04
+					.quad 0x039E401A639E401A6
+.L__real_cb1:				.quad 0x03DAAAAAB3DAAAAAB	# 8.33333333333333593622e-02
+					.quad 0x03DAAAAAB3DAAAAAB
+.L__real_cb2:				.quad 0x03C4CCCCD3C4CCCCD	# 1.24999999978138668903e-02
+					.quad 0x03C4CCCCD3C4CCCCD
+.L__real_cb3:				.quad 0x03B124A123B124A12	# 2.23219810758559851206e-03
+			.quad 0x03B124A123B124A12
+.L__real_log2_lead:     .quad 0x03F3170003F317000  # 0.693115234375
+                        .quad 0x03F3170003F317000
+.L__real_log2_tail:     .quad 0x03805FDF43805FDF4  # 0.000031946183
+                        .quad 0x03805FDF43805FDF4
+.L__real_half:		.quad 0x03f0000003f000000	# 1/2
+			.quad 0x03f0000003f000000
+.L__real_log2e_lead:       .quad 0x03FB800003FB80000  #1.4375000000
+                        .quad 0x03FB800003FB80000
+.L__real_log2e_tail:       .quad 0x03BAA3B293BAA3B29  # 0.0051950408889633
+                        .quad 0x03BAA3B293BAA3B29
+
+.L__mask_lower:			.quad 0x0ffff0000ffff0000	#
+						.quad 0x0ffff0000ffff0000
+
+.L__np_ln__table:
+	.quad	0x0000000000000000 		# 0.00000000000000000000e+00
+	.quad	0x3F8FC0A8B0FC03E4		# 1.55041813850402832031e-02
+	.quad	0x3F9F829B0E783300		# 3.07716131210327148438e-02
+	.quad	0x3FA77458F632DCFC		# 4.58095073699951171875e-02
+	.quad	0x3FAF0A30C01162A6		# 6.06245994567871093750e-02
+	.quad	0x3FB341D7961BD1D1		# 7.52233862876892089844e-02
+	.quad	0x3FB6F0D28AE56B4C		# 8.96121263504028320312e-02
+	.quad	0x3FBA926D3A4AD563		# 1.03796780109405517578e-01
+	.quad	0x3FBE27076E2AF2E6		# 1.17783010005950927734e-01
+	.quad	0x3FC0D77E7CD08E59		# 1.31576299667358398438e-01
+	.quad	0x3FC29552F81FF523		# 1.45181953907012939453e-01
+	.quad	0x3FC44D2B6CCB7D1E		# 1.58604979515075683594e-01
+	.quad	0x3FC5FF3070A793D4		# 1.71850204467773437500e-01
+	.quad	0x3FC7AB890210D909		# 1.84922337532043457031e-01
+	.quad	0x3FC9525A9CF456B4		# 1.97825729846954345703e-01
+	.quad	0x3FCAF3C94E80BFF3		# 2.10564732551574707031e-01
+	.quad	0x3FCC8FF7C79A9A22		# 2.23143517971038818359e-01
+	.quad	0x3FCE27076E2AF2E6		# 2.35566020011901855469e-01
+	.quad	0x3FCFB9186D5E3E2B		# 2.47836112976074218750e-01
+	.quad	0x3FD0A324E27390E3		# 2.59957492351531982422e-01
+	.quad	0x3FD1675CABABA60E		# 2.71933674812316894531e-01
+	.quad	0x3FD22941FBCF7966		# 2.83768117427825927734e-01
+	.quad	0x3FD2E8E2BAE11D31		# 2.95464158058166503906e-01
+	.quad	0x3FD3A64C556945EA		# 3.07025015354156494141e-01
+	.quad	0x3FD4618BC21C5EC2		# 3.18453729152679443359e-01
+	.quad	0x3FD51AAD872DF82D		# 3.29753279685974121094e-01
+	.quad	0x3FD5D1BDBF5809CA		# 3.40926527976989746094e-01
+	.quad	0x3FD686C81E9B14AF		# 3.51976394653320312500e-01
+	.quad	0x3FD739D7F6BBD007		# 3.62905442714691162109e-01
+	.quad	0x3FD7EAF83B82AFC3		# 3.73716354370117187500e-01
+	.quad	0x3FD89A3386C1425B		# 3.84411692619323730469e-01
+	.quad	0x3FD947941C2116FB		# 3.94993782043457031250e-01
+	.quad	0x3FD9F323ECBF984C		# 4.05465066432952880859e-01
+	.quad	0x3FDA9CEC9A9A084A		# 4.15827870368957519531e-01
+	.quad	0x3FDB44F77BCC8F63		# 4.26084339618682861328e-01
+	.quad	0x3FDBEB4D9DA71B7C		# 4.36236739158630371094e-01
+	.quad	0x3FDC8FF7C79A9A22		# 4.46287095546722412109e-01
+	.quad	0x3FDD32FE7E00EBD5		# 4.56237375736236572266e-01
+	.quad	0x3FDDD46A04C1C4A1		# 4.66089725494384765625e-01
+	.quad	0x3FDE744261D68788		# 4.75845873355865478516e-01
+	.quad	0x3FDF128F5FAF06ED		# 4.85507786273956298828e-01
+	.quad	0x3FDFAF588F78F31F		# 4.95077252388000488281e-01
+	.quad	0x3FE02552A5A5D0FF		# 5.04556000232696533203e-01
+	.quad	0x3FE0723E5C1CDF40		# 5.13945698738098144531e-01
+	.quad	0x3FE0BE72E4252A83		# 5.23248136043548583984e-01
+	.quad	0x3FE109F39E2D4C97		# 5.32464742660522460938e-01
+	.quad	0x3FE154C3D2F4D5EA		# 5.41597247123718261719e-01
+	.quad	0x3FE19EE6B467C96F		# 5.50647079944610595703e-01
+	.quad	0x3FE1E85F5E7040D0		# 5.59615731239318847656e-01
+	.quad	0x3FE23130D7BEBF43		# 5.68504691123962402344e-01
+	.quad	0x3FE2795E1289B11B		# 5.77315330505371093750e-01
+	.quad	0x3FE2C0E9ED448E8C		# 5.86049020290374755859e-01
+	.quad	0x3FE307D7334F10BE		# 5.94707071781158447266e-01
+	.quad	0x3FE34E289D9CE1D3		# 6.03290796279907226562e-01
+	.quad	0x3FE393E0D3562A1A		# 6.11801505088806152344e-01
+	.quad	0x3FE3D9026A7156FB		# 6.20240390300750732422e-01
+	.quad	0x3FE41D8FE84672AE		# 6.28608644008636474609e-01
+	.quad	0x3FE4618BC21C5EC2		# 6.36907458305358886719e-01
+	.quad	0x3FE4A4F85DB03EBB		# 6.45137906074523925781e-01
+	.quad	0x3FE4E7D811B75BB1		# 6.53301239013671875000e-01
+	.quad	0x3FE52A2D265BC5AB		# 6.61398470401763916016e-01
+	.quad	0x3FE56BF9D5B3F399		# 6.69430613517761230469e-01
+	.quad	0x3FE5AD404C359F2D		# 6.77398800849914550781e-01
+	.quad	0x3FE5EE02A9241675		# 6.85303986072540283203e-01
+	.quad	0x3FE62E42FEFA39EF		# 6.93147122859954833984e-01
+	.quad 0					# for alignment
+
+.L__np_ln_lead_table:
+    .long 0x00000000  # 0.000000000000 0
+    .long 0x3C7E0000  # 0.015502929688 1
+    .long 0x3CFC1000  # 0.030769348145 2
+    .long 0x3D3BA000  # 0.045806884766 3
+    .long 0x3D785000  # 0.060623168945 4
+    .long 0x3D9A0000  # 0.075195312500 5
+    .long 0x3DB78000  # 0.089599609375 6
+    .long 0x3DD49000  # 0.103790283203 7
+    .long 0x3DF13000  # 0.117767333984 8
+    .long 0x3E06B000  # 0.131530761719 9
+    .long 0x3E14A000  # 0.145141601563 10
+    .long 0x3E226000  # 0.158569335938 11
+    .long 0x3E2FF000  # 0.171813964844 12
+    .long 0x3E3D5000  # 0.184875488281 13
+    .long 0x3E4A9000  # 0.197814941406 14
+    .long 0x3E579000  # 0.210510253906 15
+    .long 0x3E647000  # 0.223083496094 16
+    .long 0x3E713000  # 0.235534667969 17
+    .long 0x3E7DC000  # 0.247802734375 18
+    .long 0x3E851000  # 0.259887695313 19
+    .long 0x3E8B3000  # 0.271850585938 20
+    .long 0x3E914000  # 0.283691406250 21
+    .long 0x3E974000  # 0.295410156250 22
+    .long 0x3E9D3000  # 0.307006835938 23
+    .long 0x3EA30000  # 0.318359375000 24
+    .long 0x3EA8D000  # 0.329711914063 25
+    .long 0x3EAE8000  # 0.340820312500 26
+    .long 0x3EB43000  # 0.351928710938 27
+    .long 0x3EB9C000  # 0.362792968750 28
+    .long 0x3EBF5000  # 0.373657226563 29
+    .long 0x3EC4D000  # 0.384399414063 30
+    .long 0x3ECA3000  # 0.394897460938 31
+    .long 0x3ECF9000  # 0.405395507813 32
+    .long 0x3ED4E000  # 0.415771484375 33
+    .long 0x3EDA2000  # 0.426025390625 34
+    .long 0x3EDF5000  # 0.436157226563 35
+    .long 0x3EE47000  # 0.446166992188 36
+    .long 0x3EE99000  # 0.456176757813 37
+    .long 0x3EEEA000  # 0.466064453125 38
+    .long 0x3EF3A000  # 0.475830078125 39
+    .long 0x3EF89000  # 0.485473632813 40
+    .long 0x3EFD7000  # 0.494995117188 41
+    .long 0x3F012000  # 0.504394531250 42
+    .long 0x3F039000  # 0.513916015625 43
+    .long 0x3F05F000  # 0.523193359375 44
+    .long 0x3F084000  # 0.532226562500 45
+    .long 0x3F0AA000  # 0.541503906250 46
+    .long 0x3F0CF000  # 0.550537109375 47
+    .long 0x3F0F4000  # 0.559570312500 48
+    .long 0x3F118000  # 0.568359375000 49
+    .long 0x3F13C000  # 0.577148437500 50
+    .long 0x3F160000  # 0.585937500000 51
+    .long 0x3F183000  # 0.594482421875 52
+    .long 0x3F1A7000  # 0.603271484375 53
+    .long 0x3F1C9000  # 0.611572265625 54
+    .long 0x3F1EC000  # 0.620117187500 55
+    .long 0x3F20E000  # 0.628417968750 56
+    .long 0x3F230000  # 0.636718750000 57
+    .long 0x3F252000  # 0.645019531250 58
+    .long 0x3F273000  # 0.653076171875 59
+    .long 0x3F295000  # 0.661376953125 60
+    .long 0x3F2B5000  # 0.669189453125 61
+    .long 0x3F2D6000  # 0.677246093750 62
+    .long 0x3F2F7000  # 0.685302734375 63
+    .long 0x3F317000  # 0.693115234375 64
+    .long 0					# for alignment
+
+.L__np_ln_tail_table:
+    .long 0x00000000  # 0.000000000000 0
+    .long 0x35A8B0FC  # 0.000001256848 1
+    .long 0x361B0E78  # 0.000002310522 2
+    .long 0x3631EC66  # 0.000002651266 3
+    .long 0x35C30046  # 0.000001452871 4
+    .long 0x37EBCB0E  # 0.000028108738 5
+    .long 0x37528AE5  # 0.000012549314 6
+    .long 0x36DA7496  # 0.000006510479 7
+    .long 0x3783B715  # 0.000015701671 8
+    .long 0x383F3E68  # 0.000045596069 9
+    .long 0x38297C10  # 0.000040408282 10
+    .long 0x3815B666  # 0.000035694240 11
+    .long 0x38183854  # 0.000036292084 12
+    .long 0x38448108  # 0.000046850211 13
+    .long 0x373539E9  # 0.000010801924 14
+    .long 0x3864A740  # 0.000054515200 15
+    .long 0x387BE3CD  # 0.000060055219 16
+    .long 0x3803B715  # 0.000031403342 17
+    .long 0x380C36AF  # 0.000033429529 18
+    .long 0x3892713A  # 0.000069829126 19
+    .long 0x38AE55D6  # 0.000083129547 20
+    .long 0x38A0FDE8  # 0.000076766883 21
+    .long 0x3862BAE1  # 0.000054056643 22
+    .long 0x3798AAD3  # 0.000018199358 23
+    .long 0x38C5E10E  # 0.000094356117 24
+    .long 0x382D872E  # 0.000041372310 25
+    .long 0x38DEDFAC  # 0.000106274470 26
+    .long 0x38481E9B  # 0.000047712219 27
+    .long 0x38EBFB5E  # 0.000112524940 28
+    .long 0x38783B83  # 0.000059183232 29
+    .long 0x374E1B05  # 0.000012284848 30
+    .long 0x38CA0E11  # 0.000096347307 31
+    .long 0x3891F660  # 0.000069600297 32
+    .long 0x386C9A9A  # 0.000056410769 33
+    .long 0x38777BCD  # 0.000059004688 34
+    .long 0x38A6CED4  # 0.000079540216 35
+    .long 0x38FBE3CD  # 0.000120110439 36
+    .long 0x387E7E01  # 0.000060675669 37
+    .long 0x37D40984  # 0.000025276800 38
+    .long 0x3784C3AD  # 0.000015826745 39
+    .long 0x380F5FAF  # 0.000034182969 40
+    .long 0x38AC47BC  # 0.000082149607 41
+    .long 0x392952D3  # 0.000161479504 42
+    .long 0x37F97073  # 0.000029735476 43
+    .long 0x3865C84A  # 0.000054784388 44
+    .long 0x3979CF17  # 0.000238236375 45
+    .long 0x38C3D2F5  # 0.000093376184 46
+    .long 0x38E6B468  # 0.000110008579 47
+    .long 0x383EBCE1  # 0.000045475437 48
+    .long 0x39186BDF  # 0.000145360347 49
+    .long 0x392F0945  # 0.000166927537 50
+    .long 0x38E9ED45  # 0.000111545007 51
+    .long 0x396B99A8  # 0.000224685878 52
+    .long 0x37A27674  # 0.000019367064 53
+    .long 0x397069AB  # 0.000229275480 54
+    .long 0x39013539  # 0.000123222257 55
+    .long 0x3947F423  # 0.000190690669 56
+    .long 0x3945E10E  # 0.000188712234 57
+    .long 0x38F85DB0  # 0.000118430122 58
+    .long 0x396C08DC  # 0.000225100142 59
+    .long 0x37B4996F  # 0.000021529120 60
+    .long 0x397CEADA  # 0.000241200818 61
+    .long 0x3920261B  # 0.000152729845 62
+    .long 0x35AA4906  # 0.000001268724 63
+    .long 0x3805FDF4  # 0.000031946183 64
+    .long 0					# for alignment
+
+
diff --git a/src/gas/vrs8logf.S b/src/gas/vrs8logf.S
new file mode 100644
index 0000000..a5e7ed9
--- /dev/null
+++ b/src/gas/vrs8logf.S
@@ -0,0 +1,904 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrs8logf.s
+#
+# A vector implementation of the logf libm function.
+#  This routine implemented in single precision.  It is slightly
+#  less accurate than the double precision version, but it will
+#  be better for vectorizing.
+#
+# Prototype:
+#
+#    __m128,__m128 __vrs8_logf(__m128 x1, __m128 x2);
+#
+#   Computes the natural log of x for eight packed single values.
+#   Places the results into xmm0 and xmm1.
+#   Returns proper C99 values, but may not raise status flags properly.
+#   Less than 1 ulp of error.
+#
+# This array version is basically a unrolling of the by4 scalar single
+# routine.  The second set of operations is performed by the indented
+# instructions interleaved into the first set.
+# The scheduling is done by trial and error.  The resulting code represents
+# the best time of many variations.  It would seem more interleaving could
+# be done, as there is a long stretch of the second computation that is not
+# interleaved.  But moving any of this code forward makes the routine
+# slower.
+#
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+    .text
+    .align 16
+    .p2align 4,,15
+
+# define local variable storage offsets
+.equ	p_x,0			# save x
+.equ	p_idx,0x010		# xmmword index
+.equ	p_z1,0x020		# xmmword index
+.equ	p_q,0x030		# xmmword index
+.equ	p_corr,0x040		# xmmword index
+.equ	p_omask,0x050		# xmmword index
+.equ	save_xmm6,0x060		#
+.equ	save_rbx,0x070		#
+.equ	save_xmm7,0x080		#
+.equ	save_xmm8,0x090		#
+.equ	save_xmm9,0x0a0		#
+.equ	save_xmm10,0x0b0		#
+.equ	save_xmm11,0x0c0		#
+.equ	save_xmm12,0x0d0		#
+.equ	save_xmm13,0x0d0		#
+.equ	p_x2,0x0100		# save x
+.equ	p_idx2,0x0110		# xmmword index
+.equ	p_z12,0x0120		# xmmword index
+.equ	p_q2,0x0130		# xmmword index
+
+.equ	stack_size,0x0168
+
+
+
+.globl __vrs8_logf
+    .type   __vrs8_logf,@function
+__vrs8_logf:
+	sub		$stack_size,%rsp
+	mov		%rbx,save_rbx(%rsp)	# save rbx
+
+# check e as a special case
+	movdqa	%xmm0,p_x(%rsp)	# save x
+		movdqa	%xmm1,p_x2(%rsp)	# save x
+	movdqa	%xmm0,%xmm2
+	cmpps	$0,.L__real_ef(%rip),%xmm2
+	movmskps	%xmm2,%r9d
+
+		movdqa	%xmm1,%xmm12
+		movdqa	%xmm1,%xmm9
+		movaps	%xmm1,%xmm7
+
+#
+# compute the index into the log tables
+#
+	movdqa	%xmm0,%xmm3
+	movaps	%xmm0,%xmm1
+	psrld	$23,%xmm3
+
+	#
+	# compute the index into the log tables
+	#
+		psrld	$23,%xmm9
+		subps	.L__real_one(%rip),%xmm7
+		psubd	.L__mask_127(%rip),%xmm9
+	subps	.L__real_one(%rip),%xmm1
+	psubd	.L__mask_127(%rip),%xmm3
+		cvtdq2ps	%xmm9,%xmm13			# xexp
+
+		movdqa	%xmm12,%xmm9
+		pand	.L__real_mant(%rip),%xmm9
+		xor		%r8,%r8
+		movdqa	%xmm9,%xmm8
+		movaps	.L__real_half(%rip),%xmm11							# .5
+	cvtdq2ps	%xmm3,%xmm6			# xexp
+
+	movdqa	%xmm0,%xmm3
+	pand	.L__real_mant(%rip),%xmm3
+	xor		%r8,%r8
+	movdqa	%xmm3,%xmm2
+	movaps	.L__real_half(%rip),%xmm5							# .5
+
+#/* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+	psrld	$16,%xmm3
+	lea		.L__np_ln_lead_table(%rip),%rdx
+	movdqa	%xmm3,%xmm4
+		psrld	$16,%xmm9
+		movdqa	%xmm9,%xmm10
+		psrld	$1,%xmm9
+	psrld	$1,%xmm3
+	paddd	.L__mask_040(%rip),%xmm3
+	pand	.L__mask_001(%rip),%xmm4
+	paddd	%xmm4,%xmm3
+	cvtdq2ps	%xmm3,%xmm1
+	#/* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+		paddd	.L__mask_040(%rip),%xmm9
+		pand	.L__mask_001(%rip),%xmm10
+		paddd	%xmm10,%xmm9
+		cvtdq2ps	%xmm9,%xmm7
+	packssdw	%xmm3,%xmm3
+	movq	%xmm3,p_idx(%rsp)
+		packssdw	%xmm9,%xmm9
+		movq	%xmm9,p_idx2(%rsp)
+
+
+# reduce and get u
+	movdqa	%xmm0,%xmm3
+	orps		.L__real_half(%rip),%xmm2
+
+
+	mulps	.L__real_3c000000(%rip),%xmm1				# f1 = index/128
+	# reduce and get u
+
+
+	subps	%xmm1,%xmm2											# f2 = f - f1
+	mulps	%xmm2,%xmm5
+	addps	%xmm5,%xmm1
+
+	divps	%xmm1,%xmm2				# u
+
+		movdqa	%xmm12,%xmm9
+		orps		.L__real_half(%rip),%xmm8
+
+
+		mulps	.L__real_3c000000(%rip),%xmm7				# f1 = index/128
+		subps	%xmm7,%xmm8											# f2 = f - f1
+		mulps	%xmm8,%xmm11
+		addps	%xmm11,%xmm7
+
+
+	mov		p_idx(%rsp),%rcx 			# get the indexes
+	mov		%cx,%r8w
+	ror		$16,%rcx
+	mov		-256(%rdx,%r8,4),%eax		# get the f1 value
+
+	mov		%cx,%r8w
+	ror		$16,%rcx
+	mov		-256(%rdx,%r8,4),%ebx		# get the f1 value
+	shl		$32,%rbx
+	or		%rbx,%rax
+	mov		 %rax,p_z1(%rsp) 			# save the f1 values
+
+	mov		%cx,%r8w
+	ror		$16,%rcx
+	mov		-256(%rdx,%r8,4),%eax		# get the f1 value
+
+	mov		%cx,%r8w
+	ror		$16,%rcx
+	or		-256(%rdx,%r8,4),%ebx		# get the f1 value
+	shl		$32,%rbx
+	or		%rbx,%rax
+	mov		 %rax,p_z1+8(%rsp) 			# save the f1 value
+		divps	%xmm7,%xmm8				# u
+		lea		.L__np_ln_lead_table(%rip),%rdx
+		mov		p_idx2(%rsp),%rcx 			# get the indexes
+		mov		%cx,%r8w
+		ror		$16,%rcx
+		mov		-256(%rdx,%r8,4),%eax		# get the f1 value
+
+		mov		%cx,%r8w
+		ror		$16,%rcx
+		mov		-256(%rdx,%r8,4),%ebx		# get the f1 value
+		shl		$32,%rbx
+		or		%rbx,%rax
+		mov		 %rax,p_z12(%rsp) 			# save the f1 values
+
+		mov		%cx,%r8w
+		ror		$16,%rcx
+		mov		-256(%rdx,%r8,4),%eax		# get the f1 value
+
+		mov		%cx,%r8w
+		ror		$16,%rcx
+		or		-256(%rdx,%r8,4),%ebx		# get the f1 value
+		shl		$32,%rbx
+		or		%rbx,%rax
+		mov		 %rax,p_z12+8(%rsp) 			# save the f1 value
+# solve for ln(1+u)
+	movaps	%xmm2,%xmm1				# u
+	mulps	%xmm2,%xmm2				# u^2
+	movaps	%xmm2,%xmm5
+	movaps	.L__real_cb3(%rip),%xmm3
+	mulps	%xmm2,%xmm3				#Cu2
+	mulps	%xmm1,%xmm5				# u^3
+	addps	.L__real_cb2(%rip),%xmm3 #B+Cu2
+	movaps	%xmm2,%xmm4
+	mulps	%xmm5,%xmm4				# u^5
+	movaps	.L__real_log2_lead(%rip),%xmm2
+
+	mulps	.L__real_cb1(%rip),%xmm5 #Au3
+	addps	%xmm5,%xmm1				# u+Au3
+	mulps	%xmm3,%xmm4				# u5(B+Cu2)
+
+	lea		.L__np_ln_tail_table(%rip),%rdx
+	addps	%xmm4,%xmm1				# poly
+
+# recombine
+	mov		p_idx(%rsp),%rcx 			# get the indexes
+	mov		%cx,%r8w
+	shr		$16,%rcx
+	mov		-256(%rdx,%r8,4),%eax		# get the f2 value
+
+	mov		%cx,%r8w
+	shr		$16,%rcx
+	or		-256(%rdx,%r8,4),%ebx		# get the f2 value
+	shl		$32,%rbx
+	or		%rbx,%rax
+	mov		 %rax,p_q(%rsp) 			# save the f2 value
+
+	mov		%cx,%r8w
+	shr		$16,%rcx
+	mov		-256(%rdx,%r8,4),%eax		# get the f2 value
+
+	mov		%cx,%r8w
+	mov		-256(%rdx,%r8,4),%ebx		# get the f2 value
+	shl		$32,%rbx
+	or		%rbx,%rax
+	mov		 %rax,p_q+8(%rsp) 			# save the f2 value
+
+	addps	p_q(%rsp),%xmm1 #z2	+=q
+
+	movaps	p_z1(%rsp),%xmm0			# z1  values
+
+	mulps	%xmm6,%xmm2
+	addps	%xmm2,%xmm0				#r1
+	mulps	.L__real_log2_tail(%rip),%xmm6
+	addps	%xmm6,%xmm1				#r2
+	addps	%xmm1,%xmm0
+
+
+
+# check for e
+	test		$0x0f,%r9d
+	jnz			.L__vlogf_e
+.L__f1:
+
+# check for negative numbers or zero
+	xorps	%xmm1,%xmm1
+	cmpps	$1,p_x(%rsp),%xmm1	# 0 greater than =?. catches NaNs also.
+	movmskps	%xmm1,%r9d
+	cmp		$0x0f,%r9d
+	jnz		.L__z_or_neg
+
+.L__f2:
+##  if +inf
+	movaps	p_x(%rsp),%xmm3
+	cmpps	$0,.L__real_inf(%rip),%xmm3
+	movmskps	%xmm3,%r9d
+	test		$0x0f,%r9d
+	jnz		.L__log_inf
+.L__f3:
+
+	movaps	p_x(%rsp),%xmm3
+	subps	.L__real_one(%rip),%xmm3
+	andps	.L__real_notsign(%rip),%xmm3
+	cmpps	$2,.L__real_threshold(%rip),%xmm3
+	movmskps	%xmm3,%r9d
+	test	$0x0f,%r9d
+	jnz		.L__near_one
+.L__f4:
+
+# finish the second set of calculations
+
+	# solve for ln(1+u)
+		movaps	%xmm8,%xmm7				# u
+		mulps	%xmm8,%xmm8				# u^2
+		movaps	%xmm8,%xmm11
+
+		movaps	.L__real_cb3(%rip),%xmm9
+		mulps	%xmm8,%xmm9				#Cu2
+		mulps	%xmm7,%xmm11				# u^3
+		addps	.L__real_cb2(%rip),%xmm9 #B+Cu2
+		movaps	%xmm8,%xmm10
+		mulps	%xmm11,%xmm10				# u^5
+		movaps	.L__real_log2_lead(%rip),%xmm8
+
+		mulps	.L__real_cb1(%rip),%xmm11 #Au3
+		addps	%xmm11,%xmm7				# u+Au3
+		mulps	%xmm9,%xmm10				# u5(B+Cu2)
+		addps	%xmm10,%xmm7				# poly
+
+
+	# recombine
+		lea		.L__np_ln_tail_table(%rip),%rdx
+		mov		p_idx2(%rsp),%rcx 			# get the indexes
+		mov		%cx,%r8w
+		shr		$16,%rcx
+		mov		-256(%rdx,%r8,4),%eax		# get the f2 value
+
+		mov		%cx,%r8w
+		shr		$16,%rcx
+		or		-256(%rdx,%r8,4),%ebx		# get the f2 value
+		shl		$32,%rbx
+		or		%rbx,%rax
+		mov		 %rax,p_q2(%rsp) 			# save the f2 value
+
+		mov		%cx,%r8w
+		shr		$16,%rcx
+		mov		-256(%rdx,%r8,4),%eax		# get the f2 value
+
+		mov		%cx,%r8w
+		mov		-256(%rdx,%r8,4),%ebx		# get the f2 value
+		shl		$32,%rbx
+		or		%rbx,%rax
+		mov		 %rax,p_q2+8(%rsp) 			# save the f2 value
+		addps	p_q2(%rsp),%xmm7 #z2	+=q
+		movaps	p_z12(%rsp),%xmm1			# z1  values
+
+		mulps	%xmm13,%xmm8
+		addps	%xmm8,%xmm1				#r1
+		mulps	.L__real_log2_tail(%rip),%xmm13
+		addps	%xmm13,%xmm7				#r2
+		addps	%xmm7,%xmm1
+
+	# check e as a special case
+		movaps	p_x2(%rsp),%xmm10
+		cmpps	$0,.L__real_ef(%rip),%xmm10
+		movmskps	%xmm10,%r9d
+	# check for e
+		test		$0x0f,%r9d
+		jnz			.L__vlogf_e2
+.L__f12:
+
+	# check for negative numbers or zero
+		xorps	%xmm7,%xmm7
+		cmpps	$1,p_x2(%rsp),%xmm7	# 0 greater than =?. catches NaNs also.
+		movmskps	%xmm7,%r9d
+		cmp		$0x0f,%r9d
+		jnz		.L__z_or_neg2
+
+.L__f22:
+	##  if +inf
+		movaps	p_x2(%rsp),%xmm9
+		cmpps	$0,.L__real_inf(%rip),%xmm9
+		movmskps	%xmm9,%r9d
+		test		$0x0f,%r9d
+		jnz		.L__log_inf2
+.L__f32:
+
+		movaps	p_x2(%rsp),%xmm9
+		subps	.L__real_one(%rip),%xmm9
+		andps	.L__real_notsign(%rip),%xmm9
+		cmpps	$2,.L__real_threshold(%rip),%xmm9
+		movmskps	%xmm9,%r9d
+		test	$0x0f,%r9d
+		jnz		.L__near_one2
+.L__f42:
+
+
+.L__finish:
+	mov		save_rbx(%rsp),%rbx		# restore rbx
+	add		$stack_size,%rsp
+	ret
+
+.L__vlogf_e:
+	movdqa	p_x(%rsp),%xmm2
+	cmpps	$0,.L__real_ef(%rip),%xmm2
+	movdqa	%xmm2,%xmm3
+	andnps	%xmm0,%xmm3							# keep the non-e values
+	andps	.L__real_one(%rip),%xmm2			# setup the 1 values
+	orps	%xmm3,%xmm2							# merge
+	movdqa	%xmm2,%xmm0							# and replace
+	jmp		.L__f1
+
+.L__vlogf_e2:
+		movdqa	p_x2(%rsp),%xmm2
+		cmpps	$0,.L__real_ef(%rip),%xmm2
+		movdqa	%xmm2,%xmm3
+		andnps	%xmm1,%xmm3							# keep the non-e values
+		andps	.L__real_one(%rip),%xmm2			# setup the 1 values
+		orps	%xmm3,%xmm2							# merge
+		movdqa	%xmm2,%xmm1							# and replace
+		jmp		.L__f12
+
+	.align	16
+.L__near_one:
+# saves 10 cycles
+#      r = x - 1.0;
+	movdqa	%xmm3,p_omask(%rsp)	# save ones mask
+	movaps	p_x(%rsp),%xmm3
+	movaps	.L__real_two(%rip),%xmm2
+	subps	.L__real_one(%rip),%xmm3	   # r
+#      u          = r / (2.0 + r);
+	addps	%xmm3,%xmm2
+	movaps	%xmm3,%xmm1
+	divps	%xmm2,%xmm1		# u
+	movaps	.L__real_ca4(%rip),%xmm4	  #D
+	movaps	.L__real_ca3(%rip),%xmm5	  #C
+#      correction = r * u;
+	movaps	%xmm3,%xmm6
+	mulps	%xmm1,%xmm6		# correction
+	movdqa	%xmm6,p_corr(%rsp)	# save correction
+#      u          = u + u;
+	addps	%xmm1,%xmm1		#u
+	movaps	%xmm1,%xmm2
+	mulps	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulps	%xmm1,%xmm5		# Cu
+	movaps	%xmm1,%xmm6
+	mulps	%xmm2,%xmm6		# u^3
+	mulps	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulps	%xmm6,%xmm4		#Du^3
+
+	addps	.L__real_ca1(%rip),%xmm2	# +A
+	movaps	%xmm6,%xmm1
+	mulps	%xmm1,%xmm1		# u^6
+	addps	%xmm4,%xmm5		#Cu+Du3
+
+	mulps	%xmm6,%xmm2		#u3(A+Bu2)
+	mulps	%xmm5,%xmm1		#u6(Cu+Du3)
+	addps	%xmm1,%xmm2
+	subps	p_corr(%rsp),%xmm2		# -correction
+
+#      return r + r2;
+	addps	%xmm2,%xmm3
+
+	movdqa	p_omask(%rsp),%xmm6
+	movdqa	%xmm6,%xmm2
+	andnps	%xmm0,%xmm6					# keep the non-nearone values
+	andps	%xmm3,%xmm2					# setup the nearone values
+	orps	%xmm6,%xmm2					# merge
+	movdqa	%xmm2,%xmm0					# and replace
+
+	jmp		.L__f4
+
+
+	.align	16
+.L__near_one2:
+# saves 10 cycles
+#      r = x - 1.0;
+		movdqa	%xmm9,p_omask(%rsp)	# save ones mask
+		movaps	p_x2(%rsp),%xmm3
+		movaps	.L__real_two(%rip),%xmm2
+		subps	.L__real_one(%rip),%xmm3	   # r
+	#      u          = r / (2.0 + r);
+		addps	%xmm3,%xmm2
+		movaps	%xmm3,%xmm7
+		divps	%xmm2,%xmm7		# u
+		movaps	.L__real_ca4(%rip),%xmm4	  #D
+		movaps	.L__real_ca3(%rip),%xmm5	  #C
+	#      correction = r * u;
+		movaps	%xmm3,%xmm6
+		mulps	%xmm7,%xmm6		# correction
+		movdqa	%xmm6,p_corr(%rsp)	# save correction
+	#      u          = u + u;
+		addps	%xmm7,%xmm7		#u
+		movaps	%xmm7,%xmm2
+		mulps	%xmm2,%xmm2		#v =u^2
+	#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+		mulps	%xmm7,%xmm5		# Cu
+		movaps	%xmm7,%xmm6
+		mulps	%xmm2,%xmm6		# u^3
+		mulps	.L__real_ca2(%rip),%xmm2	#Bu^2
+		mulps	%xmm6,%xmm4		#Du^3
+
+		addps	.L__real_ca1(%rip),%xmm2	# +A
+		movaps	%xmm6,%xmm7
+		mulps	%xmm7,%xmm7		# u^6
+		addps	%xmm4,%xmm5		#Cu+Du3
+
+		mulps	%xmm6,%xmm2		#u3(A+Bu2)
+		mulps	%xmm5,%xmm7		#u6(Cu+Du3)
+		addps	%xmm7,%xmm2
+		subps	p_corr(%rsp),%xmm2		# -correction
+
+	#      return r + r2;
+		addps	%xmm2,%xmm3
+
+		movdqa	p_omask(%rsp),%xmm6
+		movdqa	%xmm6,%xmm2
+		andnps	%xmm1,%xmm6					# keep the non-nearone values
+		andps	%xmm3,%xmm2					# setup the nearone values
+		orps	%xmm6,%xmm2					# merge
+		movdqa	%xmm2,%xmm1					# and replace
+
+		jmp		.L__f42
+
+# we have a zero, a negative number, or both.
+# the mask is already in .LNaNs,%xmm1 are also picked up here, along with -inf.
+.L__z_or_neg:
+# deal with negatives first
+	movdqa	%xmm1,%xmm3
+	andps	%xmm0,%xmm3							# keep the non-error values
+	andnps	.L__real_nan(%rip),%xmm1			# setup the nan values
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+# check for +/- 0
+	xorps	%xmm1,%xmm1
+	cmpps	$0,p_x(%rsp),%xmm1	# 0 ?.
+	movmskps	%xmm1,%r9d
+	test		$0x0f,%r9d
+	jz		.L__zn2
+
+	movdqa	%xmm1,%xmm3
+	andnps	%xmm0,%xmm3							# keep the non-error values
+	andps	.L__real_ninf(%rip),%xmm1		# ; C99 specs -inf for +-0
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+
+.L__zn2:
+# check for NaNs
+	movaps	p_x(%rsp),%xmm3
+	andps	.L__real_inf(%rip),%xmm3
+	cmpps	$0,.L__real_inf(%rip),%xmm3		# mask for max exponent
+
+	movdqa	p_x(%rsp),%xmm4
+	pand	.L__real_mant(%rip),%xmm4		# mask for non-zero mantissa
+	pcmpeqd	.L__real_zero(%rip),%xmm4
+	pandn	%xmm3,%xmm4							# mask for NaNs
+	movdqa	%xmm4,%xmm2
+	movdqa	p_x(%rsp),%xmm1			# isolate the NaNs
+	pand	%xmm4,%xmm1
+
+	pand	.L__real_qnanbit(%rip),%xmm4		# now we have a mask that will set QNaN bit
+	por		%xmm1,%xmm4							# turn SNaNs to QNaNs
+
+	movdqa	%xmm2,%xmm1
+	andnps	%xmm0,%xmm2							# keep the non-error values
+	orps	%xmm4,%xmm2							# merge
+	movdqa	%xmm2,%xmm0							# and replace
+	xorps	%xmm4,%xmm4
+
+	jmp		.L__f2
+
+# handle only +inf	 log(+inf) = inf
+.L__log_inf:
+	movdqa	%xmm3,%xmm1
+	andnps	%xmm0,%xmm3							# keep the non-error values
+	andps	p_x(%rsp),%xmm1			# setup the +inf values
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+	jmp		.L__f3
+
+
+.L__z_or_neg2:
+	# deal with negatives first
+		movdqa	%xmm7,%xmm3
+		andps	%xmm1,%xmm3							# keep the non-error values
+		andnps	.L__real_nan(%rip),%xmm7			# setup the nan values
+		orps	%xmm3,%xmm7							# merge
+		movdqa	%xmm7,%xmm1							# and replace
+	# check for +/- 0
+		xorps	%xmm7,%xmm7
+		cmpps	$0,p_x2(%rsp),%xmm7	# 0 ?.
+		movmskps	%xmm7,%r9d
+		test		$0x0f,%r9d
+		jz		.L__zn22
+
+		movdqa	%xmm7,%xmm3
+		andnps	%xmm1,%xmm3							# keep the non-error values
+		andps	.L__real_ninf(%rip),%xmm7		# ; C99 specs -inf for +-0
+		orps	%xmm3,%xmm7							# merge
+		movdqa	%xmm7,%xmm1							# and replace
+
+.L__zn22:
+	# check for NaNs
+		movaps	p_x2(%rsp),%xmm3
+		andps	.L__real_inf(%rip),%xmm3
+		cmpps	$0,.L__real_inf(%rip),%xmm3		# mask for max exponent
+
+		movdqa	p_x2(%rsp),%xmm4
+		pand	.L__real_mant(%rip),%xmm4		# mask for non-zero mantissa
+		pcmpeqd	.L__real_zero(%rip),%xmm4
+		pandn	%xmm3,%xmm4							# mask for NaNs
+		movdqa	%xmm4,%xmm2
+		movdqa	p_x2(%rsp),%xmm7			# isolate the NaNs
+		pand	%xmm4,%xmm7
+
+		pand	.L__real_qnanbit(%rip),%xmm4		# now we have a mask that will set QNaN bit
+		por		%xmm7,%xmm4							# turn SNaNs to QNaNs
+
+		movdqa	%xmm2,%xmm7
+		andnps	%xmm1,%xmm2							# keep the non-error values
+		orps	%xmm4,%xmm2							# merge
+		movdqa	%xmm2,%xmm1							# and replace
+		xorps	%xmm4,%xmm4
+
+		jmp		.L__f22
+
+	# handle only +inf	 log(+inf) = inf
+.L__log_inf2:
+		movdqa	%xmm9,%xmm7
+		andnps	%xmm1,%xmm9							# keep the non-error values
+		andps	p_x2(%rsp),%xmm7			# setup the +inf values
+		orps	%xmm9,%xmm7							# merge
+		movdqa	%xmm7,%xmm1							# and replace
+		jmp		.L__f32
+
+
+        .data
+        .align 64
+
+.L__real_zero:				.quad 0x00000000000000000	# 1.0
+					.quad 0x00000000000000000
+.L__real_one:				.quad 0x03f8000003f800000	# 1.0
+					.quad 0x03f8000003f800000
+.L__real_two:				.quad 0x04000000040000000	# 1.0
+					.quad 0x04000000040000000
+.L__real_ninf:				.quad 0x0ff800000ff800000	# -inf
+					.quad 0x0ff800000ff800000
+.L__real_inf:				.quad 0x07f8000007f800000	# +inf
+					.quad 0x07f8000007f800000
+.L__real_nan:				.quad 0x07fc000007fc00000	# NaN
+					.quad 0x07fc000007fc00000
+.L__real_ef:				.quad 0x0402DF854402DF854	# float e
+					.quad 0x0402DF854402DF854
+
+.L__real_sign:				.quad 0x08000000080000000	# sign bit
+					.quad 0x08000000080000000
+.L__real_notsign:			.quad 0x07ffFFFFF7ffFFFFF	# ^sign bit
+					.quad 0x07ffFFFFF7ffFFFFF
+.L__real_qnanbit:			.quad 0x00040000000400000	# quiet nan bit
+					.quad 0x00040000000400000
+.L__real_mant:				.quad 0x0007FFFFF007FFFFF	# mantipsa bits
+					.quad 0x0007FFFFF007FFFFF
+.L__real_3c000000:			.quad 0x03c0000003c000000	# /* 0.0078125 = 1/128 */
+					.quad 0x03c0000003c000000
+.L__mask_127:				.quad 0x00000007f0000007f	#
+					.quad 0x00000007f0000007f
+.L__mask_040:				.quad 0x00000004000000040	#
+					.quad 0x00000004000000040
+.L__mask_001:				.quad 0x00000000100000001	#
+					.quad 0x00000000100000001
+
+
+.L__real_threshold:			.quad 0x03CF5C28F3CF5C28F	# .03
+					.quad 0x03CF5C28F3CF5C28F
+
+.L__real_ca1:				.quad 0x03DAAAAAB3DAAAAAB	# 8.33333333333317923934e-02
+					.quad 0x03DAAAAAB3DAAAAAB
+.L__real_ca2:				.quad 0x03C4CCCCD3C4CCCCD	# 1.25000000037717509602e-02
+					.quad 0x03C4CCCCD3C4CCCCD
+.L__real_ca3:				.quad 0x03B1249183B124918	# 2.23213998791944806202e-03
+					.quad 0x03B1249183B124918
+.L__real_ca4:				.quad 0x039E401A639E401A6	# 4.34887777707614552256e-04
+					.quad 0x039E401A639E401A6
+.L__real_cb1:				.quad 0x03DAAAAAB3DAAAAAB	# 8.33333333333333593622e-02
+					.quad 0x03DAAAAAB3DAAAAAB
+.L__real_cb2:				.quad 0x03C4CCCCD3C4CCCCD	# 1.24999999978138668903e-02
+					.quad 0x03C4CCCCD3C4CCCCD
+.L__real_cb3:				.quad 0x03B124A123B124A12	# 2.23219810758559851206e-03
+			.quad 0x03B124A123B124A12
+.L__real_log2_lead:     .quad 0x03F3170003F317000  # 0.693115234375
+                        .quad 0x03F3170003F317000
+.L__real_log2_tail:     .quad 0x03805FDF43805FDF4  # 0.000031946183
+                        .quad 0x03805FDF43805FDF4
+.L__real_half:		.quad 0x03f0000003f000000	# 1/2
+			.quad 0x03f0000003f000000
+
+
+.L__np_ln__table:
+	.quad	0x0000000000000000 		# 0.00000000000000000000e+00
+	.quad	0x3F8FC0A8B0FC03E4		# 1.55041813850402832031e-02
+	.quad	0x3F9F829B0E783300		# 3.07716131210327148438e-02
+	.quad	0x3FA77458F632DCFC		# 4.58095073699951171875e-02
+	.quad	0x3FAF0A30C01162A6		# 6.06245994567871093750e-02
+	.quad	0x3FB341D7961BD1D1		# 7.52233862876892089844e-02
+	.quad	0x3FB6F0D28AE56B4C		# 8.96121263504028320312e-02
+	.quad	0x3FBA926D3A4AD563		# 1.03796780109405517578e-01
+	.quad	0x3FBE27076E2AF2E6		# 1.17783010005950927734e-01
+	.quad	0x3FC0D77E7CD08E59		# 1.31576299667358398438e-01
+	.quad	0x3FC29552F81FF523		# 1.45181953907012939453e-01
+	.quad	0x3FC44D2B6CCB7D1E		# 1.58604979515075683594e-01
+	.quad	0x3FC5FF3070A793D4		# 1.71850204467773437500e-01
+	.quad	0x3FC7AB890210D909		# 1.84922337532043457031e-01
+	.quad	0x3FC9525A9CF456B4		# 1.97825729846954345703e-01
+	.quad	0x3FCAF3C94E80BFF3		# 2.10564732551574707031e-01
+	.quad	0x3FCC8FF7C79A9A22		# 2.23143517971038818359e-01
+	.quad	0x3FCE27076E2AF2E6		# 2.35566020011901855469e-01
+	.quad	0x3FCFB9186D5E3E2B		# 2.47836112976074218750e-01
+	.quad	0x3FD0A324E27390E3		# 2.59957492351531982422e-01
+	.quad	0x3FD1675CABABA60E		# 2.71933674812316894531e-01
+	.quad	0x3FD22941FBCF7966		# 2.83768117427825927734e-01
+	.quad	0x3FD2E8E2BAE11D31		# 2.95464158058166503906e-01
+	.quad	0x3FD3A64C556945EA		# 3.07025015354156494141e-01
+	.quad	0x3FD4618BC21C5EC2		# 3.18453729152679443359e-01
+	.quad	0x3FD51AAD872DF82D		# 3.29753279685974121094e-01
+	.quad	0x3FD5D1BDBF5809CA		# 3.40926527976989746094e-01
+	.quad	0x3FD686C81E9B14AF		# 3.51976394653320312500e-01
+	.quad	0x3FD739D7F6BBD007		# 3.62905442714691162109e-01
+	.quad	0x3FD7EAF83B82AFC3		# 3.73716354370117187500e-01
+	.quad	0x3FD89A3386C1425B		# 3.84411692619323730469e-01
+	.quad	0x3FD947941C2116FB		# 3.94993782043457031250e-01
+	.quad	0x3FD9F323ECBF984C		# 4.05465066432952880859e-01
+	.quad	0x3FDA9CEC9A9A084A		# 4.15827870368957519531e-01
+	.quad	0x3FDB44F77BCC8F63		# 4.26084339618682861328e-01
+	.quad	0x3FDBEB4D9DA71B7C		# 4.36236739158630371094e-01
+	.quad	0x3FDC8FF7C79A9A22		# 4.46287095546722412109e-01
+	.quad	0x3FDD32FE7E00EBD5		# 4.56237375736236572266e-01
+	.quad	0x3FDDD46A04C1C4A1		# 4.66089725494384765625e-01
+	.quad	0x3FDE744261D68788		# 4.75845873355865478516e-01
+	.quad	0x3FDF128F5FAF06ED		# 4.85507786273956298828e-01
+	.quad	0x3FDFAF588F78F31F		# 4.95077252388000488281e-01
+	.quad	0x3FE02552A5A5D0FF		# 5.04556000232696533203e-01
+	.quad	0x3FE0723E5C1CDF40		# 5.13945698738098144531e-01
+	.quad	0x3FE0BE72E4252A83		# 5.23248136043548583984e-01
+	.quad	0x3FE109F39E2D4C97		# 5.32464742660522460938e-01
+	.quad	0x3FE154C3D2F4D5EA		# 5.41597247123718261719e-01
+	.quad	0x3FE19EE6B467C96F		# 5.50647079944610595703e-01
+	.quad	0x3FE1E85F5E7040D0		# 5.59615731239318847656e-01
+	.quad	0x3FE23130D7BEBF43		# 5.68504691123962402344e-01
+	.quad	0x3FE2795E1289B11B		# 5.77315330505371093750e-01
+	.quad	0x3FE2C0E9ED448E8C		# 5.86049020290374755859e-01
+	.quad	0x3FE307D7334F10BE		# 5.94707071781158447266e-01
+	.quad	0x3FE34E289D9CE1D3		# 6.03290796279907226562e-01
+	.quad	0x3FE393E0D3562A1A		# 6.11801505088806152344e-01
+	.quad	0x3FE3D9026A7156FB		# 6.20240390300750732422e-01
+	.quad	0x3FE41D8FE84672AE		# 6.28608644008636474609e-01
+	.quad	0x3FE4618BC21C5EC2		# 6.36907458305358886719e-01
+	.quad	0x3FE4A4F85DB03EBB		# 6.45137906074523925781e-01
+	.quad	0x3FE4E7D811B75BB1		# 6.53301239013671875000e-01
+	.quad	0x3FE52A2D265BC5AB		# 6.61398470401763916016e-01
+	.quad	0x3FE56BF9D5B3F399		# 6.69430613517761230469e-01
+	.quad	0x3FE5AD404C359F2D		# 6.77398800849914550781e-01
+	.quad	0x3FE5EE02A9241675		# 6.85303986072540283203e-01
+	.quad	0x3FE62E42FEFA39EF		# 6.93147122859954833984e-01
+	.quad 0					# for alignment
+
+.L__np_ln_lead_table:
+    .long 0x00000000  # 0.000000000000 0
+    .long 0x3C7E0000  # 0.015502929688 1
+    .long 0x3CFC1000  # 0.030769348145 2
+    .long 0x3D3BA000  # 0.045806884766 3
+    .long 0x3D785000  # 0.060623168945 4
+    .long 0x3D9A0000  # 0.075195312500 5
+    .long 0x3DB78000  # 0.089599609375 6
+    .long 0x3DD49000  # 0.103790283203 7
+    .long 0x3DF13000  # 0.117767333984 8
+    .long 0x3E06B000  # 0.131530761719 9
+    .long 0x3E14A000  # 0.145141601563 10
+    .long 0x3E226000  # 0.158569335938 11
+    .long 0x3E2FF000  # 0.171813964844 12
+    .long 0x3E3D5000  # 0.184875488281 13
+    .long 0x3E4A9000  # 0.197814941406 14
+    .long 0x3E579000  # 0.210510253906 15
+    .long 0x3E647000  # 0.223083496094 16
+    .long 0x3E713000  # 0.235534667969 17
+    .long 0x3E7DC000  # 0.247802734375 18
+    .long 0x3E851000  # 0.259887695313 19
+    .long 0x3E8B3000  # 0.271850585938 20
+    .long 0x3E914000  # 0.283691406250 21
+    .long 0x3E974000  # 0.295410156250 22
+    .long 0x3E9D3000  # 0.307006835938 23
+    .long 0x3EA30000  # 0.318359375000 24
+    .long 0x3EA8D000  # 0.329711914063 25
+    .long 0x3EAE8000  # 0.340820312500 26
+    .long 0x3EB43000  # 0.351928710938 27
+    .long 0x3EB9C000  # 0.362792968750 28
+    .long 0x3EBF5000  # 0.373657226563 29
+    .long 0x3EC4D000  # 0.384399414063 30
+    .long 0x3ECA3000  # 0.394897460938 31
+    .long 0x3ECF9000  # 0.405395507813 32
+    .long 0x3ED4E000  # 0.415771484375 33
+    .long 0x3EDA2000  # 0.426025390625 34
+    .long 0x3EDF5000  # 0.436157226563 35
+    .long 0x3EE47000  # 0.446166992188 36
+    .long 0x3EE99000  # 0.456176757813 37
+    .long 0x3EEEA000  # 0.466064453125 38
+    .long 0x3EF3A000  # 0.475830078125 39
+    .long 0x3EF89000  # 0.485473632813 40
+    .long 0x3EFD7000  # 0.494995117188 41
+    .long 0x3F012000  # 0.504394531250 42
+    .long 0x3F039000  # 0.513916015625 43
+    .long 0x3F05F000  # 0.523193359375 44
+    .long 0x3F084000  # 0.532226562500 45
+    .long 0x3F0AA000  # 0.541503906250 46
+    .long 0x3F0CF000  # 0.550537109375 47
+    .long 0x3F0F4000  # 0.559570312500 48
+    .long 0x3F118000  # 0.568359375000 49
+    .long 0x3F13C000  # 0.577148437500 50
+    .long 0x3F160000  # 0.585937500000 51
+    .long 0x3F183000  # 0.594482421875 52
+    .long 0x3F1A7000  # 0.603271484375 53
+    .long 0x3F1C9000  # 0.611572265625 54
+    .long 0x3F1EC000  # 0.620117187500 55
+    .long 0x3F20E000  # 0.628417968750 56
+    .long 0x3F230000  # 0.636718750000 57
+    .long 0x3F252000  # 0.645019531250 58
+    .long 0x3F273000  # 0.653076171875 59
+    .long 0x3F295000  # 0.661376953125 60
+    .long 0x3F2B5000  # 0.669189453125 61
+    .long 0x3F2D6000  # 0.677246093750 62
+    .long 0x3F2F7000  # 0.685302734375 63
+    .long 0x3F317000  # 0.693115234375 64
+    .long 0					# for alignment
+
+.L__np_ln_tail_table:
+    .long 0x00000000  # 0.000000000000 0
+    .long 0x35A8B0FC  # 0.000001256848 1
+    .long 0x361B0E78  # 0.000002310522 2
+    .long 0x3631EC66  # 0.000002651266 3
+    .long 0x35C30046  # 0.000001452871 4
+    .long 0x37EBCB0E  # 0.000028108738 5
+    .long 0x37528AE5  # 0.000012549314 6
+    .long 0x36DA7496  # 0.000006510479 7
+    .long 0x3783B715  # 0.000015701671 8
+    .long 0x383F3E68  # 0.000045596069 9
+    .long 0x38297C10  # 0.000040408282 10
+    .long 0x3815B666  # 0.000035694240 11
+    .long 0x38183854  # 0.000036292084 12
+    .long 0x38448108  # 0.000046850211 13
+    .long 0x373539E9  # 0.000010801924 14
+    .long 0x3864A740  # 0.000054515200 15
+    .long 0x387BE3CD  # 0.000060055219 16
+    .long 0x3803B715  # 0.000031403342 17
+    .long 0x380C36AF  # 0.000033429529 18
+    .long 0x3892713A  # 0.000069829126 19
+    .long 0x38AE55D6  # 0.000083129547 20
+    .long 0x38A0FDE8  # 0.000076766883 21
+    .long 0x3862BAE1  # 0.000054056643 22
+    .long 0x3798AAD3  # 0.000018199358 23
+    .long 0x38C5E10E  # 0.000094356117 24
+    .long 0x382D872E  # 0.000041372310 25
+    .long 0x38DEDFAC  # 0.000106274470 26
+    .long 0x38481E9B  # 0.000047712219 27
+    .long 0x38EBFB5E  # 0.000112524940 28
+    .long 0x38783B83  # 0.000059183232 29
+    .long 0x374E1B05  # 0.000012284848 30
+    .long 0x38CA0E11  # 0.000096347307 31
+    .long 0x3891F660  # 0.000069600297 32
+    .long 0x386C9A9A  # 0.000056410769 33
+    .long 0x38777BCD  # 0.000059004688 34
+    .long 0x38A6CED4  # 0.000079540216 35
+    .long 0x38FBE3CD  # 0.000120110439 36
+    .long 0x387E7E01  # 0.000060675669 37
+    .long 0x37D40984  # 0.000025276800 38
+    .long 0x3784C3AD  # 0.000015826745 39
+    .long 0x380F5FAF  # 0.000034182969 40
+    .long 0x38AC47BC  # 0.000082149607 41
+    .long 0x392952D3  # 0.000161479504 42
+    .long 0x37F97073  # 0.000029735476 43
+    .long 0x3865C84A  # 0.000054784388 44
+    .long 0x3979CF17  # 0.000238236375 45
+    .long 0x38C3D2F5  # 0.000093376184 46
+    .long 0x38E6B468  # 0.000110008579 47
+    .long 0x383EBCE1  # 0.000045475437 48
+    .long 0x39186BDF  # 0.000145360347 49
+    .long 0x392F0945  # 0.000166927537 50
+    .long 0x38E9ED45  # 0.000111545007 51
+    .long 0x396B99A8  # 0.000224685878 52
+    .long 0x37A27674  # 0.000019367064 53
+    .long 0x397069AB  # 0.000229275480 54
+    .long 0x39013539  # 0.000123222257 55
+    .long 0x3947F423  # 0.000190690669 56
+    .long 0x3945E10E  # 0.000188712234 57
+    .long 0x38F85DB0  # 0.000118430122 58
+    .long 0x396C08DC  # 0.000225100142 59
+    .long 0x37B4996F  # 0.000021529120 60
+    .long 0x397CEADA  # 0.000241200818 61
+    .long 0x3920261B  # 0.000152729845 62
+    .long 0x35AA4906  # 0.000001268724 63
+    .long 0x3805FDF4  # 0.000031946183 64
+    .long 0					# for alignment
+
+
diff --git a/src/gas/vrsacosf.S b/src/gas/vrsacosf.S
new file mode 100644
index 0000000..1620009
--- /dev/null
+++ b/src/gas/vrsacosf.S
@@ -0,0 +1,2291 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrsacosf.s
+#
+# A vector implementation of the cos libm function.
+#
+# Prototype:
+#
+#    vrsa_cosf(int n, float* x, float* y);
+#
+# Computes Cosine of x for an array of input values.
+# Places the results into the supplied y array.
+# Does not perform error checking.
+# Denormal inputs may produce unexpected results.
+# This inlines a routine that computes 4 single precision Cosine values at a time.
+# The four values are passed as packed single in xmm10.
+# The four results are returned as packed singles in xmm10.
+# Note that this represents a non-standard ABI usage, as no ABI
+# ( and indeed C) currently allows returning 2 values for a function.
+# It is expected that some compilers may be able to take advantage of this
+# interface when implementing vectorized loops.  Using the array implementation
+# of the routine requires putting the inputs into memory, and retrieving
+# the results from memory.  This routine eliminates the need for this
+# overhead if the data does not already reside in memory.
+# Author: Harsha Jagasia
+# Email:  harsha.jagasia@amd.com
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.data
+.align 64
+.L__real_7fffffffffffffff: .quad 0x07fffffffffffffff	#Sign bit zero
+			.quad 0x07fffffffffffffff
+.L__real_3ff0000000000000: .quad 0x03ff0000000000000	# 1.0
+			.quad 0x03ff0000000000000
+.L__real_v2p__27:		.quad 0x03e40000000000000	# 2p-27
+			.quad 0x03e40000000000000
+.L__real_3fe0000000000000: .quad 0x03fe0000000000000	# 0.5
+			.quad 0x03fe0000000000000
+.L__real_3fc5555555555555: .quad 0x03fc5555555555555	# 0.166666666666
+			.quad 0x03fc5555555555555
+.L__real_3fe45f306dc9c883: .quad 0x03fe45f306dc9c883	# twobypi
+			.quad 0x03fe45f306dc9c883
+.L__real_3ff921fb54400000: .quad 0x03ff921fb54400000	# piby2_1
+			.quad 0x03ff921fb54400000
+.L__real_3dd0b4611a626331: .quad 0x03dd0b4611a626331	# piby2_1tail
+			.quad 0x03dd0b4611a626331
+.L__real_3dd0b4611a600000: .quad 0x03dd0b4611a600000	# piby2_2
+			.quad 0x03dd0b4611a600000
+.L__real_3ba3198a2e037073: .quad 0x03ba3198a2e037073	# piby2_2tail
+			.quad 0x03ba3198a2e037073
+.L__real_fffffffff8000000: .quad 0x0fffffffff8000000	# mask for stripping head and tail
+			.quad 0x0fffffffff8000000
+.L__real_8000000000000000:	.quad 0x08000000000000000	# -0  or signbit
+			.quad 0x08000000000000000
+.L__reald_one_one:		.quad 0x00000000100000001	#
+			.quad 0
+.L__reald_two_two:		.quad 0x00000000200000002	#
+			.quad 0
+.L__reald_one_zero:	.quad 0x00000000100000000	# sin_cos_filter
+			.quad 0
+.L__reald_zero_one:	.quad 0x00000000000000001	#
+			.quad 0
+.L__reald_two_zero:	.quad 0x00000000200000000	#
+			.quad 0
+.L__realq_one_one:		.quad 0x00000000000000001	#
+			.quad 0x00000000000000001	#
+.L__realq_two_two:		.quad 0x00000000000000002	#
+			.quad 0x00000000000000002	#
+.L__real_1_x_mask:		.quad 0x0ffffffffffffffff	#
+			.quad 0x03ff0000000000000	#
+.L__real_zero:		.quad 0x00000000000000000	#
+			.quad 0x00000000000000000	#
+.L__real_one:		.quad 0x00000000000000001	#
+			.quad 0x00000000000000001	#
+
+.Lcosarray:
+	.quad	0x03FA5555555502F31		#  0.0416667			c1
+	.quad	0x03FA5555555502F31
+	.quad	0x0BF56C16BF55699D7		# -0.00138889			c2
+	.quad	0x0BF56C16BF55699D7
+	.quad	0x03EFA015C50A93B49		#  2.48016e-005			c3
+	.quad	0x03EFA015C50A93B49
+	.quad	0x0BE92524743CC46B8		# -2.75573e-007			c4
+	.quad	0x0BE92524743CC46B8
+
+.Lsinarray:
+	.quad	0x0BFC555555545E87D		# -0.166667	   		s1
+	.quad	0x0BFC555555545E87D
+	.quad	0x03F811110DF01232D		# 0.00833333	   		s2
+	.quad	0x03F811110DF01232D
+	.quad	0x0BF2A013A88A37196		# -0.000198413			s3
+	.quad	0x0BF2A013A88A37196
+	.quad	0x03EC6DBE4AD1572D5		# 2.75573e-006			s4
+	.quad	0x03EC6DBE4AD1572D5
+
+.Lsincosarray:
+	.quad	0x0BFC555555545E87D		# -0.166667	   		s1
+	.quad	0x03FA5555555502F31		# 0.0416667		   	c1
+	.quad	0x03F811110DF01232D		# 0.00833333	   		s2
+	.quad	0x0BF56C16BF55699D7
+	.quad	0x0BF2A013A88A37196		# -0.000198413			s3
+	.quad	0x03EFA015C50A93B49
+	.quad	0x03EC6DBE4AD1572D5		# 2.75573e-006			s4
+	.quad	0x0BE92524743CC46B8
+
+.Lcossinarray:
+	.quad	0x03FA5555555502F31		# 0.0416667		   	c1
+	.quad	0x0BFC555555545E87D		# -0.166667	   		s1
+	.quad	0x0BF56C16BF55699D7		#				c2
+	.quad	0x03F811110DF01232D
+	.quad	0x03EFA015C50A93B49		#				c3
+	.quad	0x0BF2A013A88A37196
+	.quad	0x0BE92524743CC46B8		#				c4
+	.quad	0x03EC6DBE4AD1572D5
+
+
+.align 8
+	.Levencos_oddsin_tbl:
+		.quad	.Lcoscos_coscos_piby4		# 0		*	; Done
+		.quad	.Lcoscos_cossin_piby4		# 1		+	; Done
+		.quad	.Lcoscos_sincos_piby4		# 2			; Done
+		.quad	.Lcoscos_sinsin_piby4		# 3		+	; Done
+
+		.quad	.Lcossin_coscos_piby4		# 4			; Done
+		.quad	.Lcossin_cossin_piby4		# 5		*	; Done
+		.quad	.Lcossin_sincos_piby4		# 6			; Done
+		.quad	.Lcossin_sinsin_piby4		# 7			; Done
+
+		.quad	.Lsincos_coscos_piby4		# 8			; Done
+		.quad	.Lsincos_cossin_piby4		# 9			; TBD
+		.quad	.Lsincos_sincos_piby4		# 10		*	; Done
+		.quad	.Lsincos_sinsin_piby4		# 11			; Done
+
+		.quad	.Lsinsin_coscos_piby4		# 12			; Done
+		.quad	.Lsinsin_cossin_piby4		# 13		+	; Done
+		.quad	.Lsinsin_sincos_piby4		# 14			; Done
+		.quad	.Lsinsin_sinsin_piby4		# 15		*	; Done
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+        .weak vrsa_cosf_
+        .set vrsa_cosf_,__vrsa_cosf__
+        .weak vrsa_cosf__
+        .set vrsa_cosf__,__vrsa_cosf__
+
+    .text
+    .align 16
+    .p2align 4,,15
+
+#FORTRAN subroutine implementation of array cos
+#VRSA_COSF(N,X,Y)
+#C equivalent*/
+#void vrsa_cosf__(int * n, double *x, double *y)
+#{
+#       vrsa_cosf(*n,x,y);
+#}
+
+.globl __vrsa_cosf__
+    .type   __vrsa_cosf__,@function
+__vrsa_cosf__:
+    mov         (%rdi),%edi
+
+    .align 16
+    .p2align 4,,15
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# define local variable storage offsets
+.equ	p_temp,0		# temporary for get/put bits operation
+.equ	p_temp1,0x10		# temporary for get/put bits operation
+
+.equ	save_xmm6,0x20		# temporary for get/put bits operation
+.equ	save_xmm7,0x30		# temporary for get/put bits operation
+.equ	save_xmm8,0x40		# temporary for get/put bits operation
+.equ	save_xmm9,0x50		# temporary for get/put bits operation
+.equ	save_xmm0,0x60		# temporary for get/put bits operation
+.equ	save_xmm11,0x70		# temporary for get/put bits operation
+.equ	save_xmm12,0x80		# temporary for get/put bits operation
+.equ	save_xmm13,0x90		# temporary for get/put bits operation
+.equ	save_xmm14,0x0A0		# temporary for get/put bits operation
+.equ	save_xmm15,0x0B0		# temporary for get/put bits operation
+
+.equ	r,0x0C0			# pointer to r for remainder_piby2
+.equ	rr,0x0D0		# pointer to r for remainder_piby2
+.equ	region,0x0E0		# pointer to r for remainder_piby2
+
+.equ	r1,0x0F0		# pointer to r for remainder_piby2
+.equ	rr1,0x0100		# pointer to r for remainder_piby2
+.equ	region1,0x0110		# pointer to r for remainder_piby2
+
+.equ	p_temp2,0x0120		# temporary for get/put bits operation
+.equ	p_temp3,0x0130		# temporary for get/put bits operation
+
+.equ	p_temp4,0x0140		# temporary for get/put bits operation
+.equ	p_temp5,0x0150		# temporary for get/put bits operation
+
+.equ	p_original,0x0160		# original x
+.equ	p_mask,0x0170		# original x
+.equ	p_sign,0x0180		# original x
+
+.equ	p_original1,0x0190		# original x
+.equ	p_mask1,0x01A0		# original x
+.equ	p_sign1,0x01B0		# original x
+
+.equ	save_r12,0x01C0		# temporary for get/put bits operation
+.equ	save_r13,0x01D0		# temporary for get/put bits operation
+
+.equ	save_xa,0x01E0		#qword
+.equ	save_ya,0x01F0		#qword
+
+.equ	save_nv,0x0200		#qword
+.equ	p_iter,0x0210		# qword	storage for number of loop iterations
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+.globl vrsa_cosf
+    .type   vrsa_cosf,@function
+vrsa_cosf:
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# parameters are passed in by Linux as:
+# rcx - int n
+# rdx - double *x
+# r8  - double *y
+
+
+	sub		$0x0228,%rsp
+	mov	%r12,save_r12(%rsp)	# save r12
+	mov	%r13,save_r13(%rsp)	# save r13
+
+
+
+
+
+#START PROCESS INPUT
+# save the arguments
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+	mov		%rdx,save_ya(%rsp)	# save y_array pointer
+#ifdef INTEGER64
+        mov             %rdi,%rax
+#else
+        mov             %edi,%eax
+        mov             %rax,%rdi
+#endif
+	mov		%rdi,save_nv(%rsp)	# save number of values
+# see if too few values to call the main loop
+	shr		$2,%rax				# get number of iterations
+	jz		.L__vrsa_cleanup			# jump if only single calls
+# prepare the iteration counts
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	shl		$2,%rax
+	sub		%rax,%rdi				# compute number of extra single calls
+	mov		%rdi,save_nv(%rsp)	# save number of left over values
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#START LOOP
+.align 16
+.L__vrsa_top:
+# build the input _m128d
+	mov		save_xa(%rsp),%rsi	# get x_array pointer
+	movlps	(%rsi),%xmm0
+	movhps	8(%rsi),%xmm0
+
+	prefetch	32(%rsi)
+	add		$16,%rsi
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# V4 START
+
+	movhlps		%xmm0,%xmm8
+	cvtps2pd	%xmm0,%xmm10			# convert input to double.
+	cvtps2pd	%xmm8,%xmm1			# convert input to double.
+
+movdqa	%xmm10,%xmm6
+movdqa	%xmm1,%xmm7
+movapd	.L__real_7fffffffffffffff(%rip),%xmm2
+
+andpd 	%xmm2,%xmm10	#Unsign
+andpd 	%xmm2,%xmm1	#Unsign
+
+movd	%xmm10,%rax				#rax is lower arg
+movhpd	%xmm10, p_temp+8(%rsp)			#
+mov    	p_temp+8(%rsp),%rcx			#rcx = upper arg
+
+movd	%xmm1,%r8				#r8 is lower arg
+movhpd	%xmm1, p_temp1+8(%rsp)			#
+mov    	p_temp1+8(%rsp),%r9			#r9 = upper arg
+
+movdqa	%xmm10,%xmm12
+movdqa	%xmm1,%xmm13
+
+pcmpgtd		%xmm6,%xmm12
+pcmpgtd		%xmm7,%xmm13
+movdqa		%xmm12,%xmm6
+movdqa		%xmm13,%xmm7
+psrldq		$4,%xmm12
+psrldq		$4,%xmm13
+psrldq		$8,%xmm6
+psrldq		$8,%xmm7
+
+mov 	$0x3FE921FB54442D18,%rdx			#piby4	+
+mov	$0x411E848000000000,%r10			#5e5	+
+movapd	.L__real_3fe0000000000000(%rip),%xmm4		#0.5 for later use +
+
+por	%xmm6,%xmm12
+por	%xmm7,%xmm13
+
+movapd	%xmm10,%xmm2				#x0
+movapd	%xmm1,%xmm3				#x1
+movapd	%xmm10,%xmm6				#x0
+movapd	%xmm1,%xmm7				#x1
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm2 = x, xmm4 =0.5/t, xmm6 =x
+# xmm3 = x, xmm5 =0.5/t, xmm7 =x
+.align 16
+.Leither_or_both_arg_gt_than_piby4:
+	cmp	%r10,%rax
+	jae	.Lfirst_or_next3_arg_gt_5e5
+
+	cmp	%r10,%rcx
+	jae	.Lsecond_or_next2_arg_gt_5e5
+
+	cmp	%r10,%r8
+	jae	.Lthird_or_fourth_arg_gt_5e5
+
+	cmp	%r10,%r9
+	jae	.Lfourth_arg_gt_5e5
+
+
+#      /* Find out what multiple of piby2 */
+#        npi2  = (int)(x * twobypi + 0.5);
+	movapd	.L__real_3fe45f306dc9c883(%rip),%xmm10
+	mulpd	%xmm10,%xmm2						# * twobypi
+	mulpd	%xmm10,%xmm3						# * twobypi
+
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	addpd	%xmm4,%xmm3						# +0.5, npi2
+
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm10		# piby2_1
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm1		# piby2_1
+
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	cvttpd2dq	%xmm3,%xmm5					# convert packed double to packed integers
+
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm9		# piby2_2
+
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+	cvtdq2pd	%xmm5,%xmm3					# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+
+	movd	%xmm4,%r8						# Region
+	movd	%xmm5,%r9						# Region
+
+	mov 	.L__reald_one_zero(%rip),%rdx			#compare value for cossin path
+	mov	%r8,%r10
+	mov	%r9,%r11
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm10						# npi2 * piby2_1;
+       mulpd	%xmm3,%xmm1						# npi2 * piby2_1;
+
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+       mulpd	%xmm3,%xmm9						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm10,%xmm6						# rhead  = x - npi2 * piby2_1;
+       subpd	%xmm1,%xmm7						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm10						# t
+       movapd	%xmm7,%xmm1						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm10						# rhead
+       subpd	%xmm9,%xmm1						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm3		# npi2 * piby2_2tail
+
+       subpd	%xmm10,%xmm6						# t-rhead
+       subpd	%xmm1,%xmm7						# t-rhead
+
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       subpd	%xmm7,%xmm9						# - ((t - rhead) - rtail)
+
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       addpd	%xmm3,%xmm9						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm4  = npi2 (int), xmm10 =rhead, xmm8 =rtail, r8 = region, r10 = region, r12 = Sign
+# xmm5  = npi2 (int), xmm1 =rhead, xmm9 =rtail,  r9 = region, r11 = region, r13 = Sign
+
+	and	.L__reald_one_one(%rip),%r8		#odd/even region for cos/sin
+	and	.L__reald_one_one(%rip),%r9		#odd/even region for cos/sin
+
+
+	mov	%r10,%rax
+	mov	%r11,%rcx
+
+	shr	$1,%r10						#~AB+A~B, A is sign and B is upper bit of region
+	shr	$1,%r11						#~AB+A~B, A is sign and B is upper bit of region
+
+	xor	%rax,%r10
+	xor	%rcx,%r11
+	and	.L__reald_one_one(%rip),%r10				#(~AB+A~B)&1
+	and	.L__reald_one_one(%rip),%r11				#(~AB+A~B)&1
+
+	mov	%r10,%r12
+	mov	%r11,%r13
+
+	and	%rdx,%r12				#mask out the lower sign bit leaving the upper sign bit
+	and	%rdx,%r13				#mask out the lower sign bit leaving the upper sign bit
+
+	shl	$63,%r10				#shift lower sign bit left by 63 bits
+	shl	$63,%r11				#shift lower sign bit left by 63 bits
+	shl	$31,%r12				#shift upper sign bit left by 31 bits
+	shl	$31,%r13				#shift upper sign bit left by 31 bits
+
+	mov 	 %r10,p_sign(%rsp)		#write out lower sign bit
+	mov 	 %r12,p_sign+8(%rsp)		#write out upper sign bit
+	mov 	 %r11,p_sign1(%rsp)		#write out lower sign bit
+	mov 	 %r13,p_sign1+8(%rsp)		#write out upper sign bit
+
+
+# GET_BITS_DP64(rhead-rtail, uy);			   		; originally only rhead
+# xmm4  = Sign, xmm10 =rhead, xmm8 =rtail
+# xmm5  = Sign, xmm1  =rhead, xmm9 =rtail
+	movapd	%xmm10,%xmm6						# rhead
+	movapd	%xmm1,%xmm7						# rhead
+
+	subpd	%xmm8,%xmm10						# r = rhead - rtail
+	subpd	%xmm9,%xmm1						# r = rhead - rtail
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm4  = Sign, xmm10 = r, xmm6 =rhead, xmm8 =rtail
+# xmm5  = Sign, xmm1 = r, xmm7 =rhead, xmm9 =rtail
+
+	mov	%r8,%rax
+	mov	%r9,%rcx
+
+	movapd	%xmm10,%xmm2				# move r for r2
+	movapd	%xmm1,%xmm3				# move r for r2
+
+	mulpd	%xmm10,%xmm2				# r2
+	mulpd	%xmm1,%xmm3				# r2
+
+	and	.L__reald_zero_one(%rip),%rax
+	and	.L__reald_zero_one(%rip),%rcx
+	shr	$31,%r8
+	shr	$31,%r9
+	or	%r8,%rax
+	or	%r9,%rcx
+	shl	$2,%rcx
+	or	%rcx,%rax
+
+	leaq	.Levencos_oddsin_tbl(%rip),%rcx
+	jmp	*(%rcx,%rax,8)				#Jmp table for cos/sin calculation based on even/odd region
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lfirst_or_next3_arg_gt_5e5:
+# %rcx,,%rax r8, r9
+
+	cmp	%r10,%rcx				#is upper arg >= 5e5
+	jae	.Lboth_arg_gt_5e5
+
+.Llower_arg_gt_5e5:
+# Upper Arg is < 5e5, Lower arg is >= 5e5
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+# Be sure not to use %xmm3,%xmm1 and xmm7
+# Use %xmm8,,%xmm5 xmm0, xmm12
+#	    %xmm11,,%xmm9 xmm13
+
+
+	movlpd	%xmm10,r(%rsp)		#Save lower fp arg for remainder_piby2 call
+	movhlps	%xmm10,%xmm10		#Needed since we want to work on upper arg
+	movhlps	%xmm2,%xmm2
+	movhlps	%xmm6,%xmm6
+
+# Work on Upper arg
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm4,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm8		# xmm8 = piby2_1
+	cvttsd2si	%xmm2,%ecx				# ecx = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm0		# xmm0 = piby2_2
+	cvtsi2sd	%ecx,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm8					# npi2 * piby2_1
+	subsd	%xmm8,%xmm6					# xmm6 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm12		# xmm12 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm6,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm0					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm0,%xmm6					# xmm6 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm12     					# npi2 * piby2_2tail
+       subsd	%xmm6,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm0					# (rtail-(t-rhead))
+       addsd	%xmm12,%xmm0					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	%ecx,region+4(%rsp)			# store upper region
+       movsd	%xmm6,%xmm10
+       subsd	%xmm0,%xmm10					# xmm10 = r=(rhead-rtail)
+       subsd	%xmm10,%xmm6					# rr=rhead-r
+       subsd	%xmm0,%xmm6					# xmm6 = rr=((rhead-r) -rtail)
+       movlpd	%xmm10,r+8(%rsp)			# store upper r
+       movlpd	%xmm6,rr+8(%rsp)			# store upper rr
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#Note that volatiles will be trashed by the call
+#We will construct r, rr, region and sign
+
+# Work on Lower arg
+	mov		$0x07ff0000000000000,%r11			# is lower arg nan/inf
+	mov		%r11,%r10
+	and		%rax,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_cosf_lower_naninf
+
+	mov	  %r8,p_temp(%rsp)
+	mov	  %r9,p_temp2(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region(%rsp),%rdx			# lower arg is **NOT** nan/inf
+	lea	 r(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	mov	 r(%rsp),%rdi			#Restore lower fp arg for remainder_piby2 call
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	 p_temp(%rsp),%r8
+	mov	 p_temp2(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+	jmp 	0f
+
+.L__vrs4_cosf_lower_naninf:
+	mov	 $0x00008000000000000,%r11
+	or	 %r11,%rax
+	mov	 %rax,r(%rsp)				# r = x | 0x0008000000000000
+	mov	 %r10d,region(%rsp)			# region =0
+
+.align 16
+0:
+	jmp .Lcheck_next2_args
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lboth_arg_gt_5e5:
+#Upper Arg is >= 5e5, Lower arg is >= 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+
+	movhlps %xmm10,%xmm6		#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r11			#is lower arg nan/inf
+	mov		%r11,%r10
+	and		%rax,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_cosf_lower_naninf_of_both_gt_5e5
+
+	mov	  %rcx,p_temp(%rsp)			#Save upper arg
+	mov	  %r8,p_temp2(%rsp)
+	mov	  %r9,p_temp4(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	 r(%rsp),%rsi
+
+# added ins- changed input from xmm10 to xmm0
+	movd	%xmm10,%rdi
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	 p_temp2(%rsp),%r8
+	mov	 p_temp4(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+
+	mov	 p_temp(%rsp),%rcx			#Restore upper arg
+	jmp 	0f
+
+.L__vrs4_cosf_lower_naninf_of_both_gt_5e5:				#lower arg is nan/inf
+	mov	 $0x00008000000000000,%r11
+	or	 %r11,%rax
+	mov	 %rax,r(%rsp)				#r = x | 0x0008000000000000
+	mov	 %r10d,region(%rsp)			#region = 0
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r11			#is upper arg nan/inf
+	mov		%r11,%r10
+	and		%rcx,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_cosf_upper_naninf_of_both_gt_5e5
+
+
+	mov	  %r8,p_temp2(%rsp)
+	mov	  %r9,p_temp4(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region+4(%rsp),%rdx			#upper arg is **NOT** nan/inf
+	lea	 r+8(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	movd	 %xmm6,%rdi			#Restore upper fp arg for remainder_piby2 call
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	 p_temp2(%rsp),%r8
+	mov	 p_temp4(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+
+	jmp 	0f
+
+.L__vrs4_cosf_upper_naninf_of_both_gt_5e5:
+	mov	 $0x00008000000000000,%r11
+	or	 %r11,%rcx
+	mov	 %rcx,r+8(%rsp)				#r = x | 0x0008000000000000
+	mov	 %r10d,region+4(%rsp)			#region = 0
+
+.align 16
+0:
+	jmp .Lcheck_next2_args
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lsecond_or_next2_arg_gt_5e5:
+
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+# Do not use %xmm3,,%xmm1 xmm7
+# Restore xmm4 and %xmm3,,%xmm1 xmm7
+# Can use %xmm0,,%xmm8 xmm12
+#   %xmm9,,%xmm5 xmm11, xmm13
+
+	movhpd	 %xmm10,r+8(%rsp)	#Save upper fp arg for remainder_piby2 call
+
+# Work on Lower arg
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm4,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm8		# xmm3 = piby2_1
+	cvttsd2si	%xmm2,%eax				# ecx = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm0		# xmm1 = piby2_2
+	cvtsi2sd	%eax,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm8					# npi2 * piby2_1
+	subsd	%xmm8,%xmm6					# xmm6 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm12		# xmm7 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm6,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm0					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm0,%xmm6					# xmm6 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm12     					# npi2 * piby2_2tail
+       subsd	%xmm6,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm0					# (rtail-(t-rhead))
+       addsd	%xmm12,%xmm0					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %eax,region(%rsp)			# store upper region
+
+        subsd	%xmm0,%xmm6					# xmm10 = r=(rhead-rtail)
+
+        movlpd	 %xmm6,r(%rsp)				# store upper r
+
+
+#Work on Upper arg
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+	mov		$0x07ff0000000000000,%r11			# is upper arg nan/inf
+	mov		%r11,%r10
+	and		%rcx,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_cosf_upper_naninf
+
+	mov	 %r8,p_temp(%rsp)
+	mov	 %r9,p_temp2(%rsp)
+	movapd	 %xmm1,p_temp1(%rsp)
+	movapd	 %xmm3,p_temp3(%rsp)
+	movapd	 %xmm7,p_temp5(%rsp)
+
+	lea	 region+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 r+8(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	mov	 r+8(%rsp),%rdi				#Restore upper fp arg for remainder_piby2 call
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	p_temp(%rsp),%r8
+	mov	p_temp2(%rsp),%r9
+	movapd	p_temp1(%rsp),%xmm1
+	movapd	p_temp3(%rsp),%xmm3
+	movapd	p_temp5(%rsp),%xmm7
+	jmp 	0f
+
+.L__vrs4_cosf_upper_naninf:
+	mov	 $0x00008000000000000,%r11
+	or	 %r11,%rcx
+	mov	 %rcx,r+8(%rsp)				# r = x | 0x0008000000000000
+	mov	 %r10d,region+4(%rsp)			# region =0
+
+.align 16
+0:
+	jmp 	.Lcheck_next2_args
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcheck_next2_args:
+
+	mov	$0x411E848000000000,%r10			#5e5	+
+
+	cmp	%r10,%r8
+	jae	.Lfirst_second_done_third_or_fourth_arg_gt_5e5
+
+	cmp	%r10,%r9
+	jae	.Lfirst_second_done_fourth_arg_gt_5e5
+
+
+
+# Work on next two args, both < 5e5
+# %xmm3,,%xmm1 xmm5 = x, xmm4 = 0.5
+
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4			#Restore 0.5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm3						# * twobypi
+	addpd	%xmm4,%xmm3						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm1		# piby2_1
+	cvttpd2dq	%xmm3,%xmm5					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm9		# piby2_2
+	cvtdq2pd	%xmm5,%xmm3					# and back to double.
+
+###
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movlpd	 %xmm5,region1(%rsp)						# Region
+###
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm3,%xmm1						# npi2 * piby2_1;
+
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm3,%xmm9						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm1,%xmm7						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm7,%xmm1						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm9,%xmm1						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm3		# npi2 * piby2_2tail
+
+       subpd	%xmm1,%xmm7						# t-rhead
+       subpd	%xmm7,%xmm9						# - ((t - rhead) - rtail)
+       addpd	%xmm3,%xmm9						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+       subpd	%xmm9,%xmm1						# r = rhead - rtail
+       movapd	%xmm1,r1(%rsp)
+
+       jmp	.L__vrs4_cosf_reconstruct
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lthird_or_fourth_arg_gt_5e5:
+#first two args are < 5e5, third arg >= 5e5, fourth arg >= 5e5 or < 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+# Do not use %xmm3,,%xmm1 xmm7
+# Can use 	%xmm11,,%xmm9 xmm13
+# 	%xmm8,,%xmm5 xmm0, xmm12
+# Restore xmm4
+
+# Work on first two args, both < 5e5
+
+
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# * twobypi
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm10		# piby2_1
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+
+###
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movlpd	 %xmm4,region(%rsp)				# Region
+###
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm10						# npi2 * piby2_1;
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm10,%xmm6						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm10						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm10						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+
+       subpd	%xmm10,%xmm6						# t-rhead
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+       subpd	%xmm8,%xmm10						# r = rhead - rtail
+       movapd	%xmm10,r(%rsp)
+
+# Work on next two args, third arg >= 5e5, fourth arg >= 5e5 or < 5e5
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lfirst_second_done_third_or_fourth_arg_gt_5e5:
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+
+
+	mov	$0x411E848000000000,%r10			#5e5	+
+	cmp	%r10,%r9
+	jae	.Lboth_arg_gt_5e5_higher
+
+
+# Upper Arg is <5e5, Lower arg is >= 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+	movlpd	 %xmm1,r1(%rsp)		#Save lower fp arg for remainder_piby2 call
+	movhlps	%xmm1,%xmm1			#Needed since we want to work on upper arg
+	movhlps	%xmm3,%xmm3
+	movhlps	%xmm7,%xmm7
+
+
+# Work on Upper arg
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4		# Restore 0.5
+
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm3		# x*twobypi
+	addsd	%xmm4,%xmm3					# xmm3 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm2		# xmm2 = piby2_1
+	cvttsd2si	%xmm3,%r9d				# r9d = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm10		# xmm10 = piby2_2
+	cvtsi2sd	%r9d,%xmm3				# xmm3 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm3,%xmm2					# npi2 * piby2_1
+	subsd	%xmm2,%xmm7					# xmm7 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm7,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm3,%xmm10					# xmm10 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm10,%xmm7					# xmm7 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm3,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm7,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm10					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm10					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %r9d,region1+4(%rsp)			# store upper region
+
+       subsd	%xmm10,%xmm7					# xmm1 = r=(rhead-rtail)
+
+       movlpd	 %xmm7,r1+8(%rsp)			# store upper r
+
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+
+# Work on Lower arg
+	mov		$0x07ff0000000000000,%r11			# is lower arg nan/inf
+	mov		%r11,%r10
+	and		%r8,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_cosf_lower_naninf_higher
+
+	lea	 region1(%rsp),%rdx			# lower arg is **NOT** nan/inf
+	lea	 r1(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	mov	 r1(%rsp),%rdi				#Restore lower fp arg for remainder_piby2 call
+
+	call	 __remainder_piby2d2f@PLT
+
+	jmp 	0f
+
+.L__vrs4_cosf_lower_naninf_higher:
+	mov	 $0x00008000000000000,%r11
+	or	 %r11,%r8
+	mov	 %r8,r1(%rsp)				# r = x | 0x0008000000000000
+	mov	 %r10d,region1(%rsp)			# region =0
+
+.align 16
+0:
+	jmp 	.L__vrs4_cosf_reconstruct
+
+
+
+
+
+
+
+.align 16
+.Lboth_arg_gt_5e5_higher:
+# Upper Arg is >= 5e5, Lower arg is >= 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+
+	movhlps %xmm1,%xmm7		#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r11			#is lower arg nan/inf
+	mov		%r11,%r10
+	and		%r8,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_cosf_lower_naninf_of_both_gt_5e5_higher
+
+	mov	  %r9,p_temp1(%rsp)			#Save upper arg
+	lea	  region1(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	  r1(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	movd	 %xmm1,%rdi
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	 p_temp1(%rsp),%r9			#Restore upper arg
+
+	jmp 	0f
+
+.L__vrs4_cosf_lower_naninf_of_both_gt_5e5_higher:				#lower arg is nan/inf
+	mov	 $0x00008000000000000,%r11
+	or	 %r11,%r8
+	mov	 %r8,r1(%rsp)				#r = x | 0x0008000000000000
+	mov	 %r10d,region1(%rsp)			#region = 0
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r11			#is upper arg nan/inf
+	mov		%r11,%r10
+	and		%r9,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_cosf_upper_naninf_of_both_gt_5e5_higher
+
+	lea	 region1+4(%rsp),%rdx			#upper arg is **NOT** nan/inf
+	lea	 r1+8(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	movd	 %xmm7,%rdi			#Restore upper fp arg for remainder_piby2 call
+
+	call	 __remainder_piby2d2f@PLT
+
+	jmp 	0f
+
+.L__vrs4_cosf_upper_naninf_of_both_gt_5e5_higher:
+	mov	 $0x00008000000000000,%r11
+	or	 %r11,%r9
+	mov	 %r9,r1+8(%rsp)				#r = x | 0x0008000000000000
+	mov	 %r10d,region1+4(%rsp)			#region = 0
+
+.align 16
+0:
+
+	jmp 	.L__vrs4_cosf_reconstruct
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lfourth_arg_gt_5e5:
+#first two args are < 5e5, third arg < 5e5, fourth arg >= 5e5
+#%rcx,,%rax r8, r9
+#%xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+
+# Work on first two args, both < 5e5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# * twobypi
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm10		# piby2_1
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+
+###
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movlpd	 %xmm4,region(%rsp)				# Region
+###
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm10						# npi2 * piby2_1;
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm10,%xmm6						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm10						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm10						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+
+       subpd	%xmm10,%xmm6						# t-rhead
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+       subpd	%xmm8,%xmm10						# r = rhead - rtail
+       movapd	 %xmm10,r(%rsp)
+
+# Work on next two args, third arg < 5e5, fourth arg >= 5e5
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lfirst_second_done_fourth_arg_gt_5e5:
+
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+	movhpd	 %xmm1,r1+8(%rsp)	#Save upper fp arg for remainder_piby2 call
+
+# Work on Lower arg
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4		# Restore 0.5
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm3		# x*twobypi
+	addsd	%xmm4,%xmm3					# xmm3 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm2		# xmm2 = piby2_1
+	cvttsd2si	%xmm3,%r8d				# r8d = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm10		# xmm10 = piby2_2
+	cvtsi2sd	%r8d,%xmm3				# xmm3 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm3,%xmm2					# npi2 * piby2_1
+	subsd	%xmm2,%xmm7					# xmm7 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm7,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm3,%xmm10					# xmm10 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm10,%xmm7					# xmm7 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm3,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm7,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm10					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm10					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+        mov	 %r8d,region1(%rsp)			# store lower region
+
+        subsd	%xmm10,%xmm7					# xmm10 = r=(rhead-rtail)
+
+        movlpd	 %xmm7,r1(%rsp)				# store upper r
+
+#Work on Upper arg
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+	mov		$0x07ff0000000000000,%r11			# is upper arg nan/inf
+	mov		%r11,%r10
+	and		%r9,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_cosf_upper_naninf_higher
+
+	lea	 region1+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 r1+8(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	mov	 r1+8(%rsp),%rdi	#Restore upper fp arg for remainder_piby2 call
+
+	call	 __remainder_piby2d2f@PLT
+
+	jmp 	0f
+
+.L__vrs4_cosf_upper_naninf_higher:
+	mov	 $0x00008000000000000,%r11
+	or	 %r11,%r9
+	mov	 %r9,r1+8(%rsp)				# r = x | 0x0008000000000000
+	mov	 %r10d,region1+4(%rsp)			# region =0
+
+.align 16
+0:
+	jmp	.L__vrs4_cosf_reconstruct
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrs4_cosf_reconstruct:
+#Results
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	r(%rsp),%xmm10
+	movapd	r1(%rsp),%xmm1
+
+	mov	region(%rsp),%r8
+	mov	region1(%rsp),%r9
+	mov 	.L__reald_one_zero(%rip),%rdx		#compare value for cossin path
+
+	mov 	%r8,%r10
+	mov 	%r9,%r11
+
+	and	.L__reald_one_one(%rip),%r8		#odd/even region for cos/sin
+	and	.L__reald_one_one(%rip),%r9		#odd/even region for cos/sin
+
+	mov	%r10,%rax
+	mov	%r11,%rcx
+
+	shr	$1,%r10						#~AB+A~B, A is sign and B is upper bit of region
+	shr	$1,%r11						#~AB+A~B, A is sign and B is upper bit of region
+
+	xor	%rax,%r10
+	xor	%rcx,%r11
+	and	.L__reald_one_one(%rip),%r10				#(~AB+A~B)&1
+	and	.L__reald_one_one(%rip),%r11				#(~AB+A~B)&1
+
+	mov	%r10,%r12
+	mov	%r11,%r13
+
+	and	%rdx,%r12				#mask out the lower sign bit leaving the upper sign bit
+	and	%rdx,%r13				#mask out the lower sign bit leaving the upper sign bit
+
+	shl	$63,%r10				#shift lower sign bit left by 63 bits
+	shl	$63,%r11				#shift lower sign bit left by 63 bits
+	shl	$31,%r12				#shift upper sign bit left by 31 bits
+	shl	$31,%r13				#shift upper sign bit left by 31 bits
+
+	mov 	 %r10,p_sign(%rsp)		#write out lower sign bit
+	mov 	 %r12,p_sign+8(%rsp)		#write out upper sign bit
+	mov 	 %r11,p_sign1(%rsp)		#write out lower sign bit
+	mov 	 %r13,p_sign1+8(%rsp)		#write out upper sign bit
+
+	mov	%r8,%rax
+	mov	%r9,%rcx
+
+	movapd	%xmm10,%xmm2
+	movapd	%xmm1,%xmm3
+
+	mulpd	%xmm10,%xmm2				# r2
+	mulpd	%xmm1,%xmm3				# r2
+
+	and	.L__reald_zero_one(%rip),%rax
+	and	.L__reald_zero_one(%rip),%rcx
+	shr	$31,%r8
+	shr	$31,%r9
+	or	%r8,%rax
+	or	%r9,%rcx
+	shl	$2,%rcx
+	or	%rcx,%rax
+
+	leaq	.Levencos_oddsin_tbl(%rip),%rcx
+	jmp	*(%rcx,%rax,8)				#Jmp table for cos/sin calculation based on even/odd region
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrsa_cosf_cleanup:
+
+	movapd	p_sign(%rsp),%xmm10
+	movapd	p_sign1(%rsp),%xmm1
+	xorpd	%xmm4,%xmm10			# (+) Sign
+	xorpd	%xmm5,%xmm1			# (+) Sign
+
+	cvtpd2ps %xmm10,%xmm0
+	cvtpd2ps %xmm1,%xmm11
+	movlhps	 %xmm11,%xmm0
+
+# NEW
+
+.L__vrsa_bottom1:
+# store the result _m128d
+	mov	 save_ya(%rsp),%rdi	# get y_array pointer
+	movlps	 %xmm0,(%rdi)
+	movhps	 %xmm0,8(%rdi)
+
+	prefetch	32(%rdi)
+	add		$16,%rdi
+	mov		%rdi,save_ya(%rsp)	# save y_array pointer
+
+	mov	p_iter(%rsp),%rax	# get number of iterations
+	sub	$1,%rax
+	mov	%rax,p_iter(%rsp)	# save number of iterations
+	jnz	.L__vrsa_top
+
+# see if we need to do any extras
+	mov	save_nv(%rsp),%rax	# get number of values
+	test	%rax,%rax
+	jnz	.L__vrsa_cleanup
+
+.L__final_check:
+
+# NEW
+
+	mov	save_r12(%rsp),%r12	# restore r12
+	mov	save_r13(%rsp),%r13	# restore r13
+
+	add	$0x0228,%rsp
+	ret
+
+#NEW
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# we jump here when we have an odd number of cos calls to make at the end
+# we assume that rdx is pointing at the next x array element, r8 at the next y array element.
+# The number of values left is in save_nv
+
+.align	16
+.L__vrsa_cleanup:
+        mov             save_nv(%rsp),%rax      # get number of values
+        test            %rax,%rax               # are there any values
+        jz              .L__final_check         # exit if not
+	mov		save_xa(%rsp),%rsi
+	mov		save_ya(%rsp),%rdi
+
+
+# START WORKING FROM HERE
+# fill in a m128d with zeroes and the extra values and then make a recursive call.
+	xorps		 %xmm0,%xmm0
+	movss		 %xmm0,p_temp+4(%rsp)
+	movlps		 %xmm0,p_temp+8(%rsp)
+
+
+	mov		 (%rsi),%ecx			# we know there's at least one
+	mov	 	 %ecx,p_temp(%rsp)
+	cmp		 $2,%rax
+	jl		 .L__vrsacg
+
+	mov		 4(%rsi),%ecx			# do the second value
+	mov	 	 %ecx,p_temp+4(%rsp)
+	cmp		 $3,%rax
+	jl		 .L__vrsacg
+
+	mov		 8(%rsi),%ecx			# do the third value
+	mov	 	 %ecx,p_temp+8(%rsp)
+
+.L__vrsacg:
+	mov		$4,%rdi				# parameter for N
+	lea		p_temp(%rsp),%rsi		# &x parameter
+	lea		p_temp2(%rsp),%rdx 		# &y parameter
+	call		vrsa_cosf@PLT			# call recursively to compute four values
+
+# now copy the results to the destination array
+	mov		save_ya(%rsp),%rdi
+	mov		save_nv(%rsp),%rax			# get number of values
+
+	mov	 	p_temp2(%rsp),%ecx
+	mov		%ecx,(%rdi)			# we know there's at least one
+	cmp		$2,%rax
+	jl		.L__vrsacgf
+
+	mov	 	p_temp2+4(%rsp),%ecx
+	mov		%ecx,4(%rdi)			# do the second value
+	cmp		$3,%rax
+	jl		.L__vrsacgf
+
+	mov	 	p_temp2+8(%rsp),%ecx
+	mov		 %ecx,8(%rdi)			# do the third value
+
+.L__vrsacgf:
+	jmp		.L__final_check
+
+#NEW
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;JUMP TABLE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcoscos_coscos_piby4:
+	movapd	%xmm2,%xmm0					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lcosarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lcosarray+0x30(%rip),%xmm5			# c4
+
+	movapd	.Lcosarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lcosarray+0x10(%rip),%xmm9			# c2
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm0		# -t=r-1.0	;trash r
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0	;trash r
+
+	mulpd	%xmm2,%xmm2					# x4
+	mulpd	%xmm3,%xmm3					# x4
+
+	addpd	.Lcosarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lcosarray+0x20(%rip),%xmm5			# c3+x2c4
+
+	addpd	.Lcosarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lcosarray(%rip),%xmm9			# c1+x2c2
+
+	mulpd	%xmm2,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm3,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x4 * zc
+
+	subpd   %xmm0,%xmm4					# + t
+	subpd   %xmm11,%xmm5					# + t
+
+	jmp 	.L__vrsa_cosf_cleanup
+
+.align 16
+.Lcossin_cossin_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movdqa	.Lsincosarray+0x30(%rip),%xmm4		# s4
+	movdqa	.Lsincosarray+0x30(%rip),%xmm5		# s4
+	movapd	.Lsincosarray+0x10(%rip),%xmm8		# s2
+	movapd	.Lsincosarray+0x10(%rip),%xmm9		# s2
+
+	movapd	%xmm2,%xmm0				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+
+	mulpd	%xmm2,%xmm4				# x2s4
+	mulpd	%xmm3,%xmm5				# x2s4
+	mulpd	%xmm2,%xmm8				# x2s2
+	mulpd	%xmm3,%xmm9				# x2s2
+
+	mulpd	%xmm2,%xmm0				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lsincosarray+0x20(%rip),%xmm4		# s4+x2s3
+	addpd	.Lsincosarray+0x20(%rip),%xmm5		# s4+x2s3
+	addpd	.Lsincosarray(%rip),%xmm8		# s2+x2s1
+	addpd	.Lsincosarray(%rip),%xmm9		# s2+x2s1
+
+	mulpd	%xmm0,%xmm4				# x4(s3+x2s4)
+	mulpd	%xmm11,%xmm5				# x4(s3+x2s4)
+
+	movhlps	%xmm0,%xmm0				# move high x4 for cos term
+	movhlps	%xmm11,%xmm11				# move high x4 for cos term
+
+	movsd	%xmm2,%xmm6				# move low x2 for x3 for sin term
+	movsd	%xmm3,%xmm7				# move low x2 for x3 for sin term
+	mulsd	%xmm10,%xmm6				# get low x3 for sin term
+	mulsd	%xmm1,%xmm7				# get low x3 for sin term
+
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for sin and cos terms
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for sin and cos terms
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm2,%xmm12				# move high r for cos
+	movhlps	%xmm3,%xmm13				# move high r for cos
+
+	movhlps	%xmm4,%xmm8				# xmm4 = sin , xmm8 = cos
+	movhlps	%xmm5,%xmm9				# xmm4 = sin , xmm8 = cos
+
+	mulsd	%xmm6,%xmm4				# sin *x3
+	mulsd	%xmm7,%xmm5				# sin *x3
+
+	mulsd	%xmm0,%xmm8				# cos *x4
+	mulsd	%xmm11,%xmm9				# cos *x4
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12 	#-t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13 	#-t=r-1.0
+
+	addsd	%xmm10,%xmm4				# sin + x
+	addsd	%xmm1,%xmm5				# sin + x
+	subsd   %xmm12,%xmm8				# cos+t
+	subsd   %xmm13,%xmm9				# cos+t
+
+	movlhps	%xmm8,%xmm4
+	movlhps	%xmm9,%xmm5
+
+	jmp 	.L__vrsa_cosf_cleanup
+
+.align 16
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lsincos_cossin_piby4:
+
+	movapd	.Lsincosarray+0x30(%rip),%xmm4		# s4
+	movapd	.Lcossinarray+0x30(%rip),%xmm5		# s4
+	movdqa	.Lsincosarray+0x10(%rip),%xmm8		# s2
+	movdqa	.Lcossinarray+0x10(%rip),%xmm9		# s2
+
+	movapd	%xmm2,%xmm0				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+	movapd	%xmm3,%xmm7				# sincos term upper x2 for x3
+
+	mulpd	%xmm2,%xmm4				# x2s4
+	mulpd	%xmm3,%xmm5				# x2s4
+	mulpd	%xmm2,%xmm8				# x2s2
+	mulpd	%xmm3,%xmm9				# x2s2
+
+	mulpd	%xmm2,%xmm0				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lsincosarray+0x20(%rip),%xmm4		# s3+x2s4
+	addpd	.Lcossinarray+0x20(%rip),%xmm5		# s3+x2s4
+	addpd	.Lsincosarray(%rip),%xmm8		# s1+x2s2
+	addpd	.Lcossinarray(%rip),%xmm9		# s1+x2s2
+
+	mulpd	%xmm0,%xmm4				# x4(s3+x2s4)
+	mulpd	%xmm11,%xmm5				# x4(s3+x2s4)
+
+	movhlps	%xmm0,%xmm0				# move high x4 for cos term
+
+	movsd	%xmm2,%xmm6				# move low x2 for x3 for sin term  (cossin)
+	mulpd	%xmm1,%xmm7
+
+	mulsd	%xmm10,%xmm6				# get low x3 for sin term (cossin)
+	movhlps	%xmm7,%xmm7				# get high x3 for sin term (sincos)
+
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for cos term
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for cos term
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+
+	movhlps	%xmm2,%xmm12				# move high r for cos (cossin)
+
+
+	movhlps	%xmm4,%xmm8				# xmm8 = cos , xmm4 = sin	(cossin)
+	movhlps	%xmm5,%xmm9				# xmm9 = sin , xmm5 = cos	(sincos)
+
+	mulsd	%xmm6,%xmm4				# sin *x3
+	mulsd	%xmm11,%xmm5				# cos *x4
+	mulsd	%xmm0,%xmm8				# cos *x4
+	mulsd	%xmm7,%xmm9				# sin *x3
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12 	#-t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm3 	# -t=r-1.0
+
+	movhlps	%xmm1,%xmm11				# move high x for x for sin term    (sincos)
+
+	addsd	%xmm10,%xmm4				# sin + x	+
+	addsd	%xmm11,%xmm9				# sin + x	+
+
+	subsd   %xmm12,%xmm8				# cos+t
+	subsd   %xmm3,%xmm5				# cos+t
+
+	movlhps	%xmm8,%xmm4				# cossin
+	movlhps	%xmm9,%xmm5				# sincos
+
+	jmp	.L__vrsa_cosf_cleanup
+
+.align 16
+.Lsincos_sincos_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	.Lcossinarray+0x30(%rip),%xmm4		# s4
+	movapd	.Lcossinarray+0x30(%rip),%xmm5		# s4
+	movdqa	.Lcossinarray+0x10(%rip),%xmm8		# s2
+	movdqa	.Lcossinarray+0x10(%rip),%xmm9		# s2
+
+	movapd	%xmm2,%xmm0				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+	movapd	%xmm2,%xmm6				# move x2 for x4
+	movapd	%xmm3,%xmm7				# move x2 for x4
+
+	mulpd	%xmm2,%xmm4				# x2s6
+	mulpd	%xmm3,%xmm5				# x2s6
+	mulpd	%xmm2,%xmm8				# x2s3
+	mulpd	%xmm3,%xmm9				# x2s3
+
+	mulpd	%xmm2,%xmm0				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lcossinarray+0x20(%rip),%xmm4		# s4+x2s3
+	addpd	.Lcossinarray+0x20(%rip),%xmm5		# s4+x2s3
+	addpd	.Lcossinarray(%rip),%xmm8		# s2+x2s1
+	addpd	.Lcossinarray(%rip),%xmm9		# s2+x2s1
+
+	mulpd	%xmm0,%xmm4				# x4(s4+x2s3)
+	mulpd	%xmm11,%xmm5				# x4(s4+x2s3)
+
+	mulpd	%xmm10,%xmm6				# get low x3 for sin term
+	mulpd	%xmm1,%xmm7				# get low x3 for sin term
+	movhlps	%xmm6,%xmm6				# move low x2 for x3 for sin term
+	movhlps	%xmm7,%xmm7				# move low x2 for x3 for sin term
+
+	mulsd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for cos terms
+	mulsd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for cos terms
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm4,%xmm12				# xmm8 = sin , xmm4 = cos
+	movhlps	%xmm5,%xmm13				# xmm9 = sin , xmm5 = cos
+
+	mulsd	%xmm6,%xmm12				# sin *x3
+	mulsd	%xmm7,%xmm13				# sin *x3
+	mulsd	%xmm0,%xmm4				# cos *x4
+	mulsd	%xmm11,%xmm5				# cos *x4
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm2 	#-t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm3 	#-t=r-1.0
+
+	movhlps	%xmm10,%xmm0				# move high x for x for sin term
+	movhlps	%xmm1,%xmm11				# move high x for x for sin term
+							# Reverse 10 and 0
+
+	addsd	%xmm0,%xmm12				# sin + x
+	addsd	%xmm11,%xmm13				# sin + x
+
+	subsd   %xmm2,%xmm4				# cos+t
+	subsd   %xmm3,%xmm5				# cos+t
+
+	movlhps	%xmm12,%xmm4
+	movlhps	%xmm13,%xmm5
+	jmp 	.L__vrsa_cosf_cleanup
+
+.align 16
+.Lcossin_sincos_piby4:
+
+	movapd	.Lcossinarray+0x30(%rip),%xmm4		# s4
+	movapd	.Lsincosarray+0x30(%rip),%xmm5		# s4
+	movdqa	.Lcossinarray+0x10(%rip),%xmm8		# s2
+	movdqa	.Lsincosarray+0x10(%rip),%xmm9		# s2
+
+	movapd	%xmm2,%xmm0				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+	movapd	%xmm2,%xmm7				# upper x2 for x3 for sin term (sincos)
+
+	mulpd	%xmm2,%xmm4				# x2s4
+	mulpd	%xmm3,%xmm5				# x2s4
+	mulpd	%xmm2,%xmm8				# x2s2
+	mulpd	%xmm3,%xmm9				# x2s2
+
+	mulpd	%xmm2,%xmm0				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lcossinarray+0x20(%rip),%xmm4		# s3+x2s4
+	addpd	.Lsincosarray+0x20(%rip),%xmm5		# s3+x2s4
+	addpd	.Lcossinarray(%rip),%xmm8		# s1+x2s2
+	addpd	.Lsincosarray(%rip),%xmm9		# s1+x2s2
+
+	mulpd	%xmm0,%xmm4				# x4(s3+x2s4)
+	mulpd	%xmm11,%xmm5				# x4(s3+x2s4)
+
+	movhlps	%xmm11,%xmm11				# move high x4 for cos term
+
+	movsd	%xmm3,%xmm6				# move low x2 for x3 for sin term  (cossin)
+	mulpd	%xmm10,%xmm7
+
+	mulsd	%xmm1,%xmm6				# get low x3 for sin term (cossin)
+	movhlps	%xmm7,%xmm7				# get high x3 for sin term (sincos)
+
+	mulsd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for cos term
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for cos term
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm3,%xmm12				# move high r for cos (cossin)
+
+	movhlps	%xmm4,%xmm8				# xmm8 = sin , xmm4 = cos	(sincos)
+	movhlps	%xmm5,%xmm9				# xmm9 = cos , xmm5 = sin	(cossin)
+
+	mulsd	%xmm0,%xmm4				# cos *x4
+	mulsd	%xmm6,%xmm5				# sin *x3
+	mulsd	%xmm7,%xmm8				# sin *x3
+	mulsd	%xmm11,%xmm9				# cos *x4
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm2 	# -t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12 	# -t=r-1.0
+
+	movhlps	%xmm10,%xmm11				# move high x for x for sin term    (sincos)
+
+	subsd	%xmm2,%xmm4				# cos-(-t)
+	subsd	%xmm12,%xmm9				# cos-(-t)
+
+	addsd   %xmm11,%xmm8				# sin + x
+	addsd   %xmm1,%xmm5				# sin + x
+
+	movlhps	%xmm8,%xmm4				# cossin
+	movlhps	%xmm9,%xmm5				# sincos
+
+	jmp	.L__vrsa_cosf_cleanup
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcoscos_sinsin_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr: 	SIN
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr:	COS
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	%xmm2,%xmm0					# x2	; SIN
+	movapd	%xmm3,%xmm11					# x2	; COS
+	movapd	%xmm3,%xmm1					# copy of x2 for x4
+
+	movdqa	.Lsinarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lcosarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lsinarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lcosarray+0x10(%rip),%xmm9			# c2
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11	# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	mulpd	%xmm2,%xmm0					# x4
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11		# -t=r-1.0
+	mulpd	%xmm3,%xmm1					# x4
+
+	addpd	.Lsinarray+0x20(%rip),%xmm4				# c3+x2c4
+	addpd	.Lcosarray+0x20(%rip),%xmm5				# c3+x2c4
+	addpd	.Lsinarray(%rip),%xmm8					# c1+x2c2
+	addpd	.Lcosarray(%rip),%xmm9				# c1+x2c2
+
+	mulpd	%xmm10,%xmm2					# x3
+
+	mulpd	%xmm0,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm1,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm1,%xmm5					# x4 * zc
+
+	addpd	%xmm10,%xmm4					# +x
+	subpd   %xmm11,%xmm5					# +t
+
+	jmp 	.L__vrsa_cosf_cleanup
+
+.align 16
+.Lsinsin_coscos_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr: 	COS
+# p_sign1  = Sign, xmm1  = r, xmm3 = %xmm7,%r2 =rr:	SIN
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	%xmm2,%xmm0					# x2	; COS
+	movapd	%xmm3,%xmm11					# x2	; SIN
+	movapd	%xmm2,%xmm10					# copy of x2 for x4
+
+	movdqa	.Lcosarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lsinarray+0x30(%rip),%xmm5			# s4
+	movapd	.Lcosarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lsinarray+0x10(%rip),%xmm9			# s2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# s4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# s2*x2
+
+	mulpd	%xmm2,%xmm10					# x4
+	mulpd	%xmm3,%xmm11					# x4
+
+	addpd	.Lcosarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lsinarray+0x20(%rip),%xmm5			# s3+x2c4
+	addpd	.Lcosarray(%rip),%xmm8				# c1+x2c2
+	addpd	.Lsinarray(%rip),%xmm9				# s1+x2c2
+
+	mulpd	%xmm1,%xmm3					# x3
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+
+	mulpd	%xmm10,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm11,%xmm5					# x4(s3+x2s4)
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm0		# -t=r-1.0
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zs
+
+	mulpd	%xmm10,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x3 * zc
+
+	subpd	%xmm0,%xmm4					# +t
+	addpd   %xmm1,%xmm5					# +x
+
+	jmp 	.L__vrsa_cosf_cleanup
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcoscos_cossin_piby4:						#Derive from cossin_coscos
+	movhlps	%xmm2,%xmm0					# x2 for 0.5x2 for upper cos
+	movsd	%xmm2,%xmm6					# lower x2 for x3 for lower sin
+	movapd	%xmm3,%xmm11					# x2 for 0.5x2
+	movapd	%xmm2,%xmm12					# x2 for x4
+	movapd	%xmm3,%xmm13					# x2 for x4
+
+	movsd	.L__real_3ff0000000000000(%rip),%xmm7
+
+	movdqa	.Lsincosarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lcosarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lsincosarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lcosarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	subsd	%xmm0,%xmm7					#  t=1.0-r  for cos
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11		# -t=r-1.0
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lsincosarray+0x20(%rip),%xmm4			# c4+x2c3
+	addpd	.Lcosarray+0x20(%rip),%xmm5			# c4+x2c3
+	addpd	.Lsincosarray(%rip),%xmm8			# c2+x2c1
+	addpd	.Lcosarray(%rip),%xmm9				# c2+x2c1
+
+	movapd	%xmm12,%xmm2					# upper=x4
+	movsd	%xmm6,%xmm2					# lower=x2
+	mulsd	%xmm10,%xmm2					# lower=x2*x
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm2,%xmm4					# upper= x4 * zc
+								# lower=x3 * zs
+	mulpd	%xmm13,%xmm5					# x4 * zc
+
+	movlhps	%xmm7,%xmm10					#
+	addpd	%xmm10,%xmm4					# +x for lower sin, +t for upper cos
+	subpd   %xmm11,%xmm5					# -(-t)
+
+	jmp 	.L__vrsa_cosf_cleanup
+
+.align 16
+.Lcoscos_sincos_piby4:					#Derive from cossin_coscos
+	movsd	%xmm2,%xmm0					# x2 for 0.5x2 for lower cos
+	movapd	%xmm3,%xmm11					# x2 for 0.5x2
+	movapd	%xmm2,%xmm12					# x2 for x4
+	movapd	%xmm3,%xmm13					# x2 for x4
+	movsd	.L__real_3ff0000000000000(%rip),%xmm7
+
+	movdqa	.Lcossinarray+0x30(%rip),%xmm4			# cs4
+	movdqa	.Lcosarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lcossinarray+0x10(%rip),%xmm8			# cs2
+	movapd	.Lcosarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	subsd	%xmm0,%xmm7					# t=1.0-r  for cos
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11		# -t=r-1.0
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lcossinarray+0x20(%rip),%xmm4			# c4+x2c3
+	addpd	.Lcosarray+0x20(%rip),%xmm5			# c4+x2c3
+	addpd	.Lcossinarray(%rip),%xmm8			# c2+x2c1
+	addpd	.Lcosarray(%rip),%xmm9				# c2+x2c1
+
+	mulpd	%xmm10,%xmm2					# upper=x3 for sin
+	mulsd	%xmm10,%xmm2					# lower=x4 for cos
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm2,%xmm4					# lower= x4 * zc
+								# upper= x3 * zs
+	mulpd	%xmm13,%xmm5					# x4 * zc
+
+	movsd	%xmm7,%xmm10
+	addpd	%xmm10,%xmm4					# +x for upper sin, +t for lower cos
+	subpd   %xmm11,%xmm5					# -(-t)
+
+	jmp 	.L__vrsa_cosf_cleanup
+
+.align 16
+.Lcossin_coscos_piby4:
+	movhlps	%xmm3,%xmm0					# x2 for 0.5x2 for upper cos
+	movapd	%xmm2,%xmm11					# x2 for 0.5x2
+	movapd	%xmm2,%xmm12					# x2 for x4
+	movapd	%xmm3,%xmm13					# x2 for x4
+	movsd	%xmm3,%xmm6					# lower x2 for x3 for sin
+	movsd	.L__real_3ff0000000000000(%rip),%xmm7
+
+	movdqa	.Lcosarray+0x30(%rip),%xmm4			# cs4
+	movdqa	.Lsincosarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lcosarray+0x10(%rip),%xmm8			# cs2
+	movapd	.Lsincosarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	subsd	%xmm0,%xmm7					# t=1.0-r  for cos
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11		# -t=r-1.0
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lcosarray+0x20(%rip),%xmm4			# c4+x2c3
+	addpd	.Lsincosarray+0x20(%rip),%xmm5			# c4+x2c3
+	addpd	.Lcosarray(%rip),%xmm8				# c2+x2c1
+	addpd	.Lsincosarray(%rip),%xmm9			# c2+x2c1
+
+	movapd	%xmm13,%xmm3					# upper=x4
+	movsd	%xmm6,%xmm3					# lower x2
+	mulsd	%xmm1,%xmm3					# lower x2*x
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm12,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# upper= x4 * zc
+								# lower=x3 * zs
+
+	movlhps	%xmm7,%xmm1
+	addpd	%xmm1,%xmm5					# +x for lower sin, +t for upper cos
+	subpd   %xmm11,%xmm4					# -(-t)
+
+	jmp 	.L__vrsa_cosf_cleanup
+
+.align 16
+.Lcossin_sinsin_piby4:						# Derived from sincos_coscos
+
+	movhlps	%xmm3,%xmm0					# x2
+	movapd	%xmm3,%xmm7
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+	movsd	.L__real_3ff0000000000000(%rip),%xmm11
+
+	movdqa	.Lsinarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lsincosarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lsinarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lsincosarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	mulpd	%xmm2,%xmm12					# x4
+	subsd	%xmm0,%xmm11					# t=1.0-r for cos
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lsinarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lsincosarray+0x20(%rip),%xmm5			# c3+x2c4
+	addpd	.Lsinarray(%rip),%xmm8				# c1+x2c2
+	addpd	.Lsincosarray(%rip),%xmm9			# c1+x2c2
+
+	mulpd	%xmm10,%xmm2					# x3
+	movapd	%xmm13,%xmm3					# upper x4 for cos
+	movsd	%xmm7,%xmm3					# lower x2 for sin
+	mulsd	%xmm1,%xmm3					# lower x3=x2*x for sin
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	movlhps	%xmm11,%xmm1					# t for upper cos and x for lower sin
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zs
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm3,%xmm5					# upper=x4 * zc
+								# lower=x3 * zs
+
+	addpd   %xmm10,%xmm4					# +x
+	addpd	%xmm1,%xmm5					# +t upper, +x lower
+
+	jmp 	.L__vrsa_cosf_cleanup
+
+.align 16
+.Lsincos_coscos_piby4:
+	movsd	%xmm3,%xmm0					# x2 for 0.5x2 for lower cos
+	movapd	%xmm2,%xmm11					# x2 for 0.5x2
+	movapd	%xmm2,%xmm12					# x2 for x4
+	movapd	%xmm3,%xmm13					# x2 for x4
+	movsd	.L__real_3ff0000000000000(%rip),%xmm7
+
+	movdqa	.Lcosarray+0x30(%rip),%xmm4			# cs4
+	movdqa	.Lcossinarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lcosarray+0x10(%rip),%xmm8			# cs2
+	movapd	.Lcossinarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0	# 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11	# 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	subsd	%xmm0,%xmm7					# t=1.0-r  for cos
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lcosarray+0x20(%rip),%xmm4			# c4+x2c3
+	addpd	.Lcossinarray+0x20(%rip),%xmm5			# c4+x2c3
+	addpd	.Lcosarray(%rip),%xmm8			# c2+x2c1
+	addpd	.Lcossinarray(%rip),%xmm9			# c2+x2c1
+
+	mulpd	%xmm1,%xmm3					# upper=x3 for sin
+	mulsd	%xmm1,%xmm3					# lower=x4 for cos
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm12,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# lower= x4 * zc
+								# upper= x3 * zs
+
+	movsd	%xmm7,%xmm1
+	subpd   %xmm11,%xmm4					# -(-t)
+	addpd	%xmm1,%xmm5					# +x for upper sin, +t for lower cos
+
+
+	jmp 	.L__vrsa_cosf_cleanup
+
+.align 16
+.Lsincos_sinsin_piby4:						# Derived from sincos_coscos
+
+	movsd	%xmm3,%xmm0					# x2
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+	movsd	.L__real_3ff0000000000000(%rip),%xmm11
+
+	movdqa	.Lsinarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lcossinarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lsinarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lcossinarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	mulpd	%xmm2,%xmm12					# x4
+	subsd	%xmm0,%xmm11					# t=1.0-r for cos
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lsinarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lcossinarray+0x20(%rip),%xmm5			# c3+x2c4
+	addpd	.Lsinarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lcossinarray(%rip),%xmm9			# c1+x2c2
+
+	mulpd	%xmm10,%xmm2					# x3
+	mulpd	%xmm1,%xmm3					# upper x3 for sin
+	mulsd	%xmm1,%xmm3					# lower x4 for cos
+
+	movhlps	%xmm1,%xmm6
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	movlhps	%xmm6,%xmm11					# upper =t ; lower =x
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zszc
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm3,%xmm5					# lower=x4 * zc
+								# upper=x3 * zs
+
+	addpd   %xmm10,%xmm4					# +x
+	addpd	%xmm11,%xmm5					# +t lower, +x upper
+
+	jmp 	.L__vrsa_cosf_cleanup
+
+.align 16
+.Lsinsin_cossin_piby4:						# Derived from sincos_coscos
+
+	movhlps	%xmm2,%xmm0					# x2
+	movapd	%xmm2,%xmm7
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+	movsd	.L__real_3ff0000000000000(%rip),%xmm11
+
+	movdqa	.Lsincosarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lsinarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lsincosarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lsinarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	mulpd	%xmm2,%xmm12					# x4
+	subsd	%xmm0,%xmm11					# t=1.0-r for cos
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lsincosarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lsinarray+0x20(%rip),%xmm5			# c3+x2c4
+	addpd	.Lsincosarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lsinarray(%rip),%xmm9				# c1+x2c2
+
+	mulpd	%xmm1,%xmm3					# x3
+	movapd	%xmm12,%xmm2					# upper x4 for cos
+	movsd	%xmm7,%xmm2					# lower x2 for sin
+	mulsd	%xmm10,%xmm2					# lower x3=x2*x for sin
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	movlhps	%xmm11,%xmm10					# t for upper cos and x for lower sin
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zszc
+
+	mulpd	%xmm3,%xmm5					# x3 * zs
+	mulpd	%xmm2,%xmm4					# upper=x4 * zc
+								# lower=x3 * zs
+
+	addpd	%xmm1,%xmm5					# +x
+	addpd   %xmm10,%xmm4					# +t upper, +x lower
+
+	jmp 	.L__vrsa_cosf_cleanup
+
+.align 16
+.Lsinsin_sincos_piby4:						# Derived from sincos_coscos
+
+	movsd	%xmm2,%xmm0					# x2
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+	movsd	.L__real_3ff0000000000000(%rip),%xmm11
+
+	movdqa	.Lcossinarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lsinarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lcossinarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lsinarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	mulpd	%xmm2,%xmm12					# x4
+	subsd	%xmm0,%xmm11					# t=1.0-r for cos
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lcossinarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lsinarray+0x20(%rip),%xmm5			# c3+x2c4
+	addpd	.Lcossinarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lsinarray(%rip),%xmm9			# c1+x2c2
+
+	mulpd	%xmm1,%xmm3					# x3
+	mulpd	%xmm10,%xmm2					# upper x3 for sin
+	mulsd	%xmm10,%xmm2					# lower x4 for cos
+
+	movhlps	%xmm10,%xmm6
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	movlhps	%xmm6,%xmm11
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zszc
+
+	mulpd	%xmm3,%xmm5					# x3 * zs
+	mulpd	%xmm2,%xmm4					# lower=x4 * zc
+								# upper=x3 * zs
+
+	addpd	%xmm1,%xmm5					# +x
+	addpd   %xmm11,%xmm4					# +t lower, +x upper
+
+	jmp 	.L__vrsa_cosf_cleanup
+
+.align 16
+.Lsinsin_sinsin_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+  #x2 = x * x;
+  #(x + x * x2 * (c1 + x2 * (c2 + x2 * (c3 + x2 * c4))));
+
+  #x + x3 * ((c1 + x2 *c2) + x4 * (c3 + x2 * c4));
+
+
+	movapd	%xmm2,%xmm0					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lsinarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lsinarray+0x30(%rip),%xmm5			# c4
+
+	mulpd	%xmm2,%xmm0					# x4
+	mulpd	%xmm3,%xmm11					# x4
+
+	movapd	.Lsinarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lsinarray+0x10(%rip),%xmm9			# c2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	addpd	.Lsinarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lsinarray+0x20(%rip),%xmm5			# c3+x2c4
+
+	mulpd	%xmm10,%xmm2					# x3
+	mulpd	%xmm1,%xmm3					# x3
+
+	addpd	.Lsinarray(%rip),%xmm8				# c1+x2c2
+	addpd	.Lsinarray(%rip),%xmm9				# c1+x2c2
+
+	mulpd	%xmm0,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm11,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zs
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm3,%xmm5					# x3 * zs
+
+	addpd	%xmm10,%xmm4					# +x
+	addpd	%xmm1,%xmm5					# +x
+
+	jmp 	.L__vrsa_cosf_cleanup
diff --git a/src/gas/vrsaexpf.S b/src/gas/vrsaexpf.S
new file mode 100644
index 0000000..399943e
--- /dev/null
+++ b/src/gas/vrsaexpf.S
@@ -0,0 +1,766 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrsaexpf.s
+#
+# An array implementation of the expf libm function.
+#
+# Prototype:
+#
+#    void vrsa_expf(int n, float *x, float *y);
+#
+#   Computes e raised to the x power for an array of input values.
+#   Places the results into the supplied y array.
+#  This routine implemented in single precision.  It is slightly
+#  less accurate than the double precision version, but it will
+#  be better for vectorizing.
+# Does not perform error handling, but does return C99 values for error
+# inputs.   Denormal results are truncated to 0.
+
+# This array version is basically a unrolling of the by4 scalar single
+# routine.  The second set of operations is performed by the indented
+# instructions interleaved into the first set.
+# The scheduling is done by trial and error.  The resulting code represents
+# the best time of many variations.  It would seem more interleaving could
+# be done, as there is a long stretch of the second computation that is not
+# interleaved.  But moving any of this code forward makes the routine
+# slower.
+#
+#
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+
+# define local variable storage offsets
+.equ	p_ux,0x00		#qword
+.equ	p_ux2,0x010		#qword
+
+.equ	save_xa,0x020		#qword
+.equ	save_ya,0x028		#qword
+.equ	save_nv,0x030		#qword
+
+
+.equ	p_iter,0x038		# qword	storage for number of loop iterations
+
+.equ	p_j,0x040		# second temporary for get/put bits operation
+.equ	p_m,0x050		#qword
+.equ	p_j2,0x060		# second temporary for exponent multiply
+.equ	p_m2,0x070		#qword
+.equ	save_rbx,0x080		#qword
+
+
+.equ	stack_size,0x098
+
+       .weak vrsa_expf_
+       .set vrsa_expf_,__vrsa_expf__
+       .weak vrsa_expf__
+       .set vrsa_expf__,__vrsa_expf__
+
+# parameters are passed in by gcc as:
+# rdi - int n
+# rsi - double *x
+# rdx - double *y
+
+    .text
+    .align 16
+    .p2align 4,,15
+
+#/* a FORTRAN subroutine implementation of array expf
+#**     VRSA_EXPF(N,X,Y)
+# C equivalent*/
+#void vrsa_expf__(int * n, float *x, float *y)
+#{
+#       vrsa_expf(*n,x,y);
+#}
+.globl __vrsa_expf__
+    .type   __vrsa_expf__,@function
+__vrsa_expf__:
+    mov         (%rdi),%edi
+
+    .align 16
+    .p2align 4,,15
+.globl vrsa_expf
+    .type   vrsa_expf,@function
+vrsa_expf:
+	sub		$stack_size,%rsp
+	mov		%rbx,save_rbx(%rsp)
+
+# save the arguments
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+	mov		%rdx,save_ya(%rsp)	# save y_array pointer
+#ifdef INTEGER64
+        mov             %rdi,%rax
+#else
+        mov             %edi,%eax
+        mov             %rax,%rdi
+#endif
+	mov		%rdi,save_nv(%rsp)	# save number of values
+
+# see if too few values to call the main loop
+	shr		$3,%rax						# get number of iterations
+	jz		.L__vsa_cleanup				# jump if only single calls
+# prepare the iteration counts
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	shl		$3,%rax
+	sub		%rax,%rdi						# compute number of extra single calls
+	mov		%rdi,save_nv(%rsp)	# save number of left over values
+
+# In this second version, process the array 8 values at a time.
+
+.L__vsa_top:
+# build the input _m128
+	movaps	.L__real_thirtytwo_by_log2(%rip),%xmm3	#
+	mov		save_xa(%rsp),%rsi	# get x_array pointer
+	movups	(%rsi),%xmm0
+		movups	16(%rsi),%xmm6
+	prefetch	64(%rsi)
+	add		$32,%rsi
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+
+	movaps	 %xmm0,p_ux(%rsp)
+        maxps   .L__real_m8192(%rip),%xmm0
+		movaps	 %xmm6,p_ux2(%rsp)
+                maxps   .L__real_m8192(%rip),%xmm6
+
+
+#        /* Find m, z1 and z2 such that exp(x) = 2**m * (z1 + z2) */
+#      Step 1. Reduce the argument.
+	#    r = x * thirtytwo_by_logbaseof2;
+	movaps	.L__real_thirtytwo_by_log2(%rip),%xmm2	#
+
+	mulps	%xmm0,%xmm2
+	xor		%rax,%rax
+        minps   .L__real_8192(%rip),%xmm2
+		movaps	.L__real_thirtytwo_by_log2(%rip),%xmm5	#
+
+		mulps	%xmm6,%xmm5
+                minps   .L__real_8192(%rip),%xmm5   # protect against large input values
+
+
+#    /* Set n = nearest integer to r */
+	cvtps2dq	%xmm2,%xmm3
+	lea		.L__two_to_jby32_table(%rip),%rdi
+	cvtdq2ps	%xmm3,%xmm1
+
+		cvtps2dq	%xmm5,%xmm8
+		cvtdq2ps	%xmm8,%xmm7
+#    r1 = x - n * logbaseof2_by_32_lead;
+	movaps	.L__real_log2_by_32_head(%rip),%xmm2
+	mulps	%xmm1,%xmm2
+	subps	%xmm2,%xmm0				# r1 in xmm0,
+
+		movaps	.L__real_log2_by_32_head(%rip),%xmm5
+		mulps	%xmm7,%xmm5
+		subps	%xmm5,%xmm6				# r1 in xmm6,
+
+
+#    r2 = - n * logbaseof2_by_32_lead;
+	mulps	.L__real_log2_by_32_tail(%rip),%xmm1
+		mulps	.L__real_log2_by_32_tail(%rip),%xmm7
+
+#    j = n & 0x0000001f;
+	movdqa	%xmm3,%xmm4
+	movdqa	.L__int_mask_1f(%rip),%xmm2
+		movdqa	%xmm8,%xmm9
+		movdqa	.L__int_mask_1f(%rip),%xmm5
+	pand	%xmm4,%xmm2
+	movdqa	 %xmm2,p_j(%rsp)
+#    f1 = two_to_jby32_lead_table[j);
+
+		pand	%xmm9,%xmm5
+		movdqa	 %xmm5,p_j2(%rsp)
+
+#    *m = (n - j) / 32;
+	psubd	%xmm2,%xmm4
+	psrad	$5,%xmm4
+	movdqa	 %xmm4,p_m(%rsp)
+		psubd	%xmm5,%xmm9
+		psrad	$5,%xmm9
+		movdqa	 %xmm9,p_m2(%rsp)
+
+	movaps	%xmm0,%xmm3
+	addps	%xmm1,%xmm3				# r = r1+ r2
+
+	mov		p_j(%rsp),%eax 			# get an individual index
+		movaps	%xmm6,%xmm8
+        mov             (%rdi,%rax,4),%edx              # get the f1 value
+		addps	%xmm7,%xmm8				# r = r1+ r2
+	mov		 %edx,p_j(%rsp) 			# save the f1 value
+
+#      Step 2. Compute the polynomial.
+#    q = r1 +
+#              r*r*( 5.00000000000000008883e-01 +
+#                      r*( 1.66666666665260878863e-01 +
+#                      r*( 4.16666666662260795726e-02 +
+#                      r*( 8.33336798434219616221e-03 +
+#                      r*( 1.38889490863777199667e-03 )))));
+#    q = r + r^2/2 + r^3/6 + r^4/24 + r^5/120 + r^6/720
+#    q = r + r^2/2 + r^3/6 + r^4/24 good enough for single precision
+	movaps	%xmm3,%xmm4
+	movaps	%xmm3,%xmm2
+	mulps	%xmm2,%xmm2			# x*x
+	mulps	.L__real_1_24(%rip),%xmm4	# /24
+
+	mov		p_j+4(%rsp),%eax 			# get an individual index
+        mov             (%rdi,%rax,4),%edx              # get the f1 value
+	mov		 %edx,p_j+4(%rsp) 			# save the f1 value
+
+	addps 	.L__real_1_6(%rip),%xmm4		# +1/6
+
+	mulps	%xmm2,%xmm3			# x^3
+	mov		p_j+8(%rsp),%eax 			# get an individual index
+        mov             (%rdi,%rax,4),%edx              # get the f1 value
+	mov		 %edx,p_j+8(%rsp) 			# save the f1 value
+	mulps	.L__real_half(%rip),%xmm2	# x^2/2
+	mov		p_j+12(%rsp),%eax 			# get an individual index
+        mov             (%rdi,%rax,4),%edx              # get the f1 value
+	mov		 %edx,p_j+12(%rsp) 			# save the f1 value
+	mulps	%xmm3,%xmm4			# *x^3
+		mov		p_j2(%rsp),%eax 			# get an individual index
+        	mov             (%rdi,%rax,4),%edx              # get the f1 value
+		mov		 %edx,p_j2(%rsp) 			# save the f1 value
+
+	addps	%xmm4,%xmm1			# +r2
+
+	addps	%xmm2,%xmm1			# + x^2/2
+	addps	%xmm1,%xmm0			# +r1
+
+		movaps	%xmm8,%xmm9
+		mov		p_j2+4(%rsp),%eax 			# get an individual index
+		movaps	%xmm8,%xmm5
+		mulps	%xmm5,%xmm5			# x*x
+		mulps	.L__real_1_24(%rip),%xmm9	# /24
+
+       		mov             (%rdi,%rax,4),%edx              # get the f1 value
+		mov		 %edx,p_j2+4(%rsp) 			# save the f1 value
+
+# deal with infinite or denormal results
+        movdqa  p_m(%rsp),%xmm1
+        movdqa  p_m(%rsp),%xmm2
+        pcmpgtd .L__int_127(%rip),%xmm2
+        pminsw  .L__int_128(%rip),%xmm1 # ceil at 128
+        movmskps        %xmm2,%eax
+        test            $0x0f,%eax
+
+        paddd   .L__int_127(%rip),%xmm1 # add bias
+
+#    *z2 = f2 + ((f1 + f2) * q);
+        mulps   p_j(%rsp),%xmm0         # * f1
+        addps   p_j(%rsp),%xmm0         # + f1
+        jnz             .L__exp_largef
+.L__check1:
+
+
+	pxor	%xmm2,%xmm2				# floor at 0
+	pmaxsw	%xmm2,%xmm1
+
+	pslld	$23,%xmm1					# build 2^n
+
+	movaps	%xmm1,%xmm2
+
+
+
+# check for infinity or nan
+	movaps	p_ux(%rsp),%xmm1
+	andps	.L__real_infinity(%rip),%xmm1
+        cmpps   $0,.L__real_infinity(%rip),%xmm1
+	movmskps	%xmm1,%ebx
+	test		$0x0f,%ebx
+
+
+# end of splitexp
+#        /* Scale (z1 + z2) by 2.0**m */
+#      Step 3. Reconstitute.
+
+	mulps	%xmm2,%xmm0						# result *= 2^n
+
+# we'd like to avoid a branch, and can use cmp's and and's to
+# eliminate them.  But it adds cycles for normal cases
+# to handle events that are supposed to be exceptions.
+#  Using this branch with the
+# check above results in faster code for the normal cases.
+# And branch mispredict penalties should only come into
+# play for nans and infinities.
+	jnz		.L__exp_naninf
+.L__vsa_bottom1:
+
+		#    q = r + r^2/2 + r^3/6 + r^4/24 good enough for single precision
+		addps 	.L__real_1_6(%rip),%xmm9		# +1/6
+
+		mulps	%xmm5,%xmm8			# x^3
+		mov		p_j2+8(%rsp),%eax 			# get an individual index
+        	mov             (%rdi,%rax,4),%edx              # get the f1 value
+		mov		 %edx,p_j2+8(%rsp) 			# save the f1 value
+		mulps	.L__real_half(%rip),%xmm5	# x^2/2
+		mulps	%xmm8,%xmm9			# *x^3
+
+		mov		p_j2+12(%rsp),%eax 			# get an individual index
+        	mov             (%rdi,%rax,4),%edx              # get the f1 value
+		mov		 %edx,p_j2+12(%rsp) 			# save the f1 value
+		addps	%xmm9,%xmm7			# +r2
+
+		addps	%xmm5,%xmm7			# + x^2/2
+		addps	%xmm7,%xmm6			# +r1
+
+
+		# deal with infinite or denormal results
+                movdqa  p_m2(%rsp),%xmm7
+                movdqa  p_m2(%rsp),%xmm5
+                pcmpgtd .L__int_127(%rip),%xmm5
+                pminsw  .L__int_128(%rip),%xmm7 # ceil at 128
+                movmskps        %xmm5,%eax
+                test            $0x0f,%eax
+
+                paddd   .L__int_127(%rip),%xmm7 # add bias
+
+        #    *z2 = f2 + ((f1 + f2) * q);
+                mulps   p_j2(%rsp),%xmm6                # * f1
+                addps   p_j2(%rsp),%xmm6                # + f1
+                jnz             .L__exp_largef2
+.L__check2:
+
+		pxor	%xmm5,%xmm5				# floor at 0
+		pmaxsw	%xmm5,%xmm7
+
+		pslld	$23,%xmm7					# build 2^n
+
+		movaps	%xmm7,%xmm5
+
+
+		# check for infinity or nan
+		movaps	p_ux2(%rsp),%xmm7
+		andps	.L__real_infinity(%rip),%xmm7
+	        cmpps   $0,.L__real_infinity(%rip),%xmm7
+		movmskps	%xmm7,%ebx
+		test		$0x0f,%ebx
+
+
+		# end of splitexp
+		#        /* Scale (z1 + z2) by 2.0**m */
+		#      Step 3. Reconstitute.
+
+		mulps	%xmm5,%xmm6						# result *= 2^n
+#__vsa_bottom1:
+# store the result _m128d
+	mov		save_ya(%rsp),%rdi	# get y_array pointer
+	movups	%xmm0,(%rdi)
+
+		jnz			.L__exp_naninf2
+
+.L__vsa_bottom2:
+
+	prefetch	64(%rdi)
+	add		$32,%rdi
+	mov		%rdi,save_ya(%rsp)	# save y_array pointer
+
+# store the result _m128d
+		movups	%xmm6,-16(%rdi)
+
+	mov		p_iter(%rsp),%rax	# get number of iterations
+	sub		$1,%rax
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	jnz		.L__vsa_top
+
+
+# see if we need to do any extras
+	mov		save_nv(%rsp),%rax	# get number of values
+	test	%rax,%rax
+	jnz		.L__vsa_cleanup
+
+
+#
+.L__final_check:
+	mov		save_rbx(%rsp),%rbx		# restore rbx
+	add		$stack_size,%rsp
+	ret
+
+# at least one of the numbers needs special treatment
+.L__exp_naninf:
+	lea		p_ux(%rsp),%rcx
+	call  .L__fexp_naninf
+	jmp		.L__vsa_bottom1
+.L__exp_naninf2:
+	lea		p_ux2(%rsp),%rcx
+	movaps	%xmm6,%xmm0
+	call  .L__fexp_naninf
+	movaps	%xmm0,%xmm6
+	jmp		.L__vsa_bottom2
+
+#  deal with nans and infinities
+# This subroutine checks a packed single for nans and infinities and
+# produces the proper result from the exceptional inputs
+# Register assumptions:
+# Inputs:
+# rbx - mask of errors
+# xmm0 - computed result vector
+# Outputs:
+# xmm0 - new result vector
+# %rax,rdx,rbx,%xmm2 all modified.
+
+.L__fexp_naninf:
+	movaps	 %xmm0,p_j+8(%rsp)	# save the computed values
+	test	$1,%ebx					# first value?
+	jz		.L__Lni2
+	mov		0(%rcx),%edx	# get the input
+	call	.L__naninf
+	mov		 %edx,p_j+8(%rsp)	# copy the result
+.L__Lni2:
+	test	$2,%ebx					# second value?
+	jz		.L__Lni3
+	mov		4(%rcx),%edx	# get the input
+	call	.L__naninf
+	mov		 %edx,p_j+12(%rsp)	# copy the result
+.L__Lni3:
+	test	$4,%ebx					# third value?
+	jz		.L__Lni4
+	mov		8(%rcx),%edx	# get the input
+	call	.L__naninf
+	mov		 %edx,p_j+16(%rsp)	# copy the result
+.L__Lni4:
+	test	$8,%ebx					# fourth value?
+	jz		.L__Lnie
+	mov		12(%rcx),%edx	# get the input
+	call	.L__naninf
+	mov		 %edx,p_j+20(%rsp)	# copy the result
+.L__Lnie:
+	movaps	p_j+8(%rsp),%xmm0	# get the answers
+	ret
+
+#
+# a simple subroutine to check a scalar input value for infinity
+# or NaN and return the correct result
+# expects input in .Land,%edx returns value in edx.  Destroys eax.
+.L__naninf:
+	mov		$0x0007FFFFF,%eax
+	test	%eax,%edx
+	jnz		.L__enan					# jump if mantissa not zero, so it's a NaN
+# inf
+	mov		%edx,%eax
+	rcl		$1,%eax
+	jnc		.L__r				# exp(+inf) = inf
+	xor		%edx,%edx				# exp(-inf) = 0
+	jmp		.L__r
+
+#NaN
+.L__enan:
+	mov		$0x000400000,%eax	# convert to quiet
+	or		%eax,%edx
+.L__r:
+	ret
+
+
+	.align	16
+# we jump here when we have an odd number of exp calls to make at the
+# end
+.L__vsa_cleanup:
+        mov             save_nv(%rsp),%rax      # get number of values
+        test            %rax,%rax	        # are there any values
+        jz              .L__final_check         # exit if not
+
+	mov		save_xa(%rsp),%rsi
+	mov		save_ya(%rsp),%rdi
+
+# fill in a m128 with zeroes and the extra values and then make a recursive call.
+	xorps		%xmm0,%xmm0
+        movaps          %xmm0,p_j(%rsp)
+        movaps          %xmm0,p_j+16(%rsp)
+
+	mov		(%rsi),%ecx		# we know there's at least one
+	mov	 	%ecx,p_j(%rsp)
+	cmp		$2,%rax
+	jl		.L__vsacg
+
+	mov		4(%rsi),%ecx			# do the second value
+	mov	 	%ecx,p_j+4(%rsp)
+	cmp		$3,%rax
+	jl		.L__vsacg
+
+	mov		8(%rsi),%ecx			# do the third value
+	mov	 	%ecx,p_j+8(%rsp)
+	cmp		$4,%rax
+	jl		.L__vsacg
+
+	mov		12(%rsi),%ecx			# do the fourth value
+	mov	 	%ecx,p_j+12(%rsp)
+	cmp		$5,%rax
+	jl		.L__vsacg
+
+	mov		16(%rsi),%ecx			# do the fifth value
+	mov	 	%ecx,p_j+16(%rsp)
+	cmp		$6,%rax
+	jl		.L__vsacg
+
+	mov		20(%rsi),%ecx			# do the sixth value
+	mov	 	%ecx,p_j+20(%rsp)
+	cmp		$7,%rax
+	jl		.L__vsacg
+
+	mov		24(%rsi),%ecx			# do the last value
+	mov	 	%ecx,p_j+24(%rsp)
+
+.L__vsacg:
+	mov		$8,%rdi				# parameter for N
+	lea		p_j(%rsp),%rsi	# &x parameter
+	lea		p_j2(%rsp),%rdx	# &y parameter
+        call		vrsa_expf@PLT  # call recursively to compute four values
+
+# now copy the results to the destination array
+	mov		save_ya(%rsp),%rdi
+	mov		save_nv(%rsp),%rax	# get number of values
+	mov	 	p_j2(%rsp),%ecx
+	mov		%ecx,(%rdi)			# we know there's at least one
+	cmp		$2,%rax
+	jl		.L__vsacgf
+
+	mov	 	p_j2+4(%rsp),%ecx
+	mov		%ecx,4(%rdi)			# do the second value
+	cmp		$3,%rax
+	jl		.L__vsacgf
+
+	mov	 	p_j2+8(%rsp),%ecx
+	mov		%ecx,8(%rdi)			# do the second value
+	cmp		$4,%rax
+	jl		.L__vsacgf
+
+	mov	 	p_j2+12(%rsp),%ecx
+	mov		%ecx,12(%rdi)			# do the second value
+	cmp		$5,%rax
+	jl		.L__vsacgf
+
+	mov	 	p_j2+16(%rsp),%ecx
+	mov		%ecx,16(%rdi)		# do the second value
+	cmp		$6,%rax
+	jl		.L__vsacgf
+
+	mov	 	p_j2+20(%rsp),%ecx
+	mov		%ecx,20(%rdi)			# do the second value
+	cmp		$7,%rax
+	jl		.L__vsacgf
+
+	mov	 	p_j2+24(%rsp),%ecx
+	mov		%ecx,24(%rdi)			# do the last value
+
+.L__vsacgf:
+	jmp		.L__final_check
+
+        .align  16
+#  deal with m > 127.  In some instances, rounding during calculations
+#  can result in infinity when it shouldn't.  For these cases, we scale
+#  m down, and scale the mantissa up.
+
+.L__exp_largef:
+        movdqa    %xmm0,p_j(%rsp)    # save the mantissa portion
+        movdqa    %xmm1,p_m(%rsp)       # save the exponent portion
+        mov       %eax,%ecx              # save the error mask
+        test    $1,%ecx                  # first value?
+        jz       .L__Lf2
+        mov      p_m(%rsp),%edx # get the exponent
+        sub      $1,%edx                # scale it down
+        mov      %edx,p_m(%rsp)       # save the exponent
+        movss   p_j(%rsp),%xmm3     # get the mantissa
+        mulss   .L__real_two(%rip),%xmm3        # scale it up
+        movss    %xmm3,p_j(%rsp)   # save the mantissa
+.L__Lf2:
+        test    $2,%ecx                 # second value?
+        jz       .L__Lf3
+        mov      p_m+4(%rsp),%edx # get the exponent
+        sub      $1,%edx                # scale it down
+        mov      %edx,p_m+4(%rsp)       # save the exponent
+        movss   p_j+4(%rsp),%xmm3     # get the mantissa
+        mulss   .L__real_two(%rip),%xmm3        # scale it up
+        movss     %xmm3,p_j+4(%rsp)   # save the mantissa
+.L__Lf3:
+        test    $4,%ecx                 # third value?
+        jz       .L__Lf4
+        mov      p_m+8(%rsp),%edx # get the exponent
+        sub      $1,%edx                # scale it down
+        mov      %edx,p_m+8(%rsp)       # save the exponent
+        movss   p_j+8(%rsp),%xmm3     # get the mantissa
+        mulss   .L__real_two(%rip),%xmm3        # scale it up
+        movss    %xmm3,p_j+8(%rsp)   # save the mantissa
+.L__Lf4:
+        test    $8,%ecx                                 # fourth value?
+        jz       .L__Lfe
+        mov      p_m+12(%rsp),%edx        # get the exponent
+        sub      $1,%edx                 # scale it down
+        mov      %edx,p_m+12(%rsp)      # save the exponent
+        movss   p_j+12(%rsp),%xmm3    # get the mantissa
+        mulss   .L__real_two(%rip),%xmm3        # scale it up
+        movss     %xmm3,p_j+12(%rsp)  # save the mantissa
+.L__Lfe:
+        movaps  p_j(%rsp),%xmm0      # restore the mantissa portion back
+        movdqa  p_m(%rsp),%xmm1         # restore the exponent portion
+        jmp             .L__check1
+        .align  16
+
+.L__exp_largef2:
+        movdqa    %xmm6,p_j(%rsp)    # save the mantissa portion
+        movdqa    %xmm7,p_m2(%rsp)      # save the exponent portion
+        mov             %eax,%ecx                                       # save the error mask
+        test    $1,%ecx                                 # first value?
+        jz              .L__Lf22
+        mov             p_m2+0(%rsp),%edx       # get the exponent
+        sub             $1,%edx                                         # scale it down
+        mov               %edx,p_m2+0(%rsp)     # save the exponent
+        movss   p_j+0(%rsp),%xmm3    # get the mantissa
+        mulss   .L__real_two(%rip),%xmm3        # scale it up
+        movss     %xmm3,p_j+0(%rsp)  # save the mantissa
+.L__Lf22:
+        test    $2,%ecx                                 # second value?
+        jz              .L__Lf32
+        mov             p_m2+4(%rsp),%edx       # get the exponent
+        sub             $1,%edx                                         # scale it down
+        mov               %edx,p_m2+4(%rsp)     # save the exponent
+        movss   p_j+4(%rsp),%xmm3    # get the mantissa
+        mulss   .L__real_two(%rip),%xmm3        # scale it up
+        movss     %xmm3,p_j+4(%rsp)  # save the mantissa
+.L__Lf32:
+        test    $4,%ecx                                 # third value?
+        jz              .L__Lf42
+        mov             p_m2+8(%rsp),%edx       # get the exponent
+        sub             $1,%edx                                         # scale it down
+        mov               %edx,p_m2+8(%rsp)     # save the exponent
+        movss   p_j+8(%rsp),%xmm3    # get the mantissa
+        mulss   .L__real_two(%rip),%xmm3        # scale it up
+        movss     %xmm3,p_j+8(%rsp)  # save the mantissa
+.L__Lf42:
+        test    $8,%ecx                                 # fourth value?
+        jz              .L__Lfe2
+        mov             p_m2+12(%rsp),%edx      # get the exponent
+        sub             $1,%edx                                         # scale it down
+        mov               %edx,p_m2+12(%rsp)    # save the exponent
+        movss   p_j+12(%rsp),%xmm3   # get the mantissa
+        mulss   .L__real_two(%rip),%xmm3        # scale it up
+        movss     %xmm3,p_j+12(%rsp) # save the mantissa
+.L__Lfe2:
+        movaps  p_j(%rsp),%xmm6      # restore the mantissa portion back
+        movdqa  p_m2(%rsp),%xmm7                # restore the exponent portion
+        jmp             .L__check2
+
+
+	.data
+	.align	64
+.L__real_half:			.long 0x03f000000	# 1/2
+				.long 0x03f000000
+				.long 0x03f000000
+				.long 0x03f000000
+.L__real_two:                   .long 0x40000000        # 2
+                                .long 0x40000000
+                                .long 0x40000000
+                                .long 0x40000000
+.L__real_8192:                  .long 0x46000000        # 8192, to protect against really large numbers
+                                .long 0x46000000
+                                .long 0x46000000
+                                .long 0x46000000
+.L__real_m8192:                 .long 0xC6000000        # -8192, to protect against really small numbers
+                                .long 0xC6000000
+                                .long 0xC6000000
+                                .long 0xC6000000
+.L__real_thirtytwo_by_log2: 	.long 0x04238AA3B	# thirtytwo_by_log2
+				.long 0x04238AA3B
+				.long 0x04238AA3B
+				.long 0x04238AA3B
+.L__real_log2_by_32:		.long 0x03CB17218	# log2_by_32
+				.long 0x03CB17218
+				.long 0x03CB17218
+				.long 0x03CB17218
+.L__real_log2_by_32_head:	.long 0x03CB17000	# log2_by_32
+				.long 0x03CB17000
+				.long 0x03CB17000
+				.long 0x03CB17000
+.L__real_log2_by_32_tail:	.long 0x0B585FDF4	# log2_by_32
+				.long 0x0B585FDF4
+				.long 0x0B585FDF4
+				.long 0x0B585FDF4
+.L__real_1_6:			.long 0x03E2AAAAB	# 0.16666666666 used in polynomial
+				.long 0x03E2AAAAB
+				.long 0x03E2AAAAB
+				.long 0x03E2AAAAB
+.L__real_1_24: 			.long 0x03D2AAAAB	# 0.041666668 used in polynomial
+				.long 0x03D2AAAAB
+				.long 0x03D2AAAAB
+				.long 0x03D2AAAAB
+.L__real_1_120:			.long 0x03C088889	# 0.0083333338 used in polynomial
+				.long 0x03C088889
+				.long 0x03C088889
+				.long 0x03C088889
+.L__real_infinity:		.long 0x07f800000	# infinity
+				.long 0x07f800000
+				.long 0x07f800000
+				.long 0x07f800000
+.L__int_mask_1f:		.long 0x00000001f
+				.long 0x00000001f
+				.long 0x00000001f
+				.long 0x00000001f
+.L__int_128:			.long 0x000000080
+				.long 0x000000080
+				.long 0x000000080
+				.long 0x000000080
+.L__int_127:			.long 0x00000007f
+				.long 0x00000007f
+				.long 0x00000007f
+				.long 0x00000007f
+
+.L__two_to_jby32_table:
+	.long	0x03F800000 		# 1.0000000000000000
+	.long	0x03F82CD87		# 1.0218971486541166
+	.long	0x03F85AAC3		# 1.0442737824274138
+	.long	0x03F88980F		# 1.0671404006768237
+	.long	0x03F8B95C2		# 1.0905077326652577
+	.long	0x03F8EA43A		# 1.1143867425958924
+	.long	0x03F91C3D3		# 1.1387886347566916
+	.long	0x03F94F4F0		# 1.1637248587775775
+	.long	0x03F9837F0		# 1.1892071150027210
+	.long	0x03F9B8D3A		# 1.2152473599804690
+	.long	0x03F9EF532		# 1.2418578120734840
+	.long	0x03FA27043		# 1.2690509571917332
+	.long	0x03FA5FED7		# 1.2968395546510096
+	.long	0x03FA9A15B		# 1.3252366431597413
+	.long	0x03FAD583F		# 1.3542555469368927
+	.long	0x03FB123F6		# 1.3839098819638320
+	.long	0x03FB504F3		# 1.4142135623730951
+	.long	0x03FB8FBAF		# 1.4451808069770467
+	.long	0x03FBD08A4		# 1.4768261459394993
+	.long	0x03FC12C4D		# 1.5091644275934228
+	.long	0x03FC5672A		# 1.5422108254079407
+	.long	0x03FC9B9BE		# 1.5759808451078865
+	.long	0x03FCE248C		# 1.6104903319492543
+	.long	0x03FD2A81E		# 1.6457554781539649
+	.long	0x03FD744FD		# 1.6817928305074290
+	.long	0x03FDBFBB8		# 1.7186192981224779
+	.long	0x03FE0CCDF		# 1.7562521603732995
+	.long	0x03FE5B907		# 1.7947090750031072
+	.long	0x03FEAC0C7		# 1.8340080864093424
+	.long	0x03FEFE4BA		# 1.8741676341103000
+	.long	0x03FF5257D		# 1.9152065613971474
+	.long	0x03FFA83B3		# 1.9571441241754002
+	.long 0					# for alignment
+
+
+
diff --git a/src/gas/vrsalog10f.S b/src/gas/vrsalog10f.S
new file mode 100644
index 0000000..003eaf1
--- /dev/null
+++ b/src/gas/vrsalog10f.S
@@ -0,0 +1,1149 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrsalogf.s
+#
+# An array implementation of the logf libm function.
+#
+# Prototype:
+#
+#    void vrsa_log10f(int n, float *x, float *y);
+#
+#   Computes the natural log of x.
+#   Places the results into the supplied y array.
+# Does not perform error handling, but does return C99 values for error
+# inputs.   Denormal results are truncated to 0.
+
+# This array version is basically a unrolling of the by4 scalar single
+# routine.  The second set of operations is performed by the indented
+# instructions interleaved into the first set.
+#
+#
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+
+       .weak vrsa_log10f_
+       .set vrsa_log10f_,__vrsa_log10f__
+       .weak vrsa_log10f__
+       .set vrsa_log10f__,__vrsa_log10f__
+
+    .text
+    .align 16
+    .p2align 4,,15
+
+#/* a FORTRAN subroutine implementation of array logf
+#**     VRSA_LOG10F(N,X,Y)
+# C equivalent*/
+#void vrsa_log10f__(int * n, float *x, float *y)
+#{
+#       vrsa_log10f(*n,x,y);
+#}
+.globl __vrsa_log10f__
+    .type   __vrsa_log10f__,@function
+__vrsa_log10f__:
+    mov         (%rdi),%edi
+
+    .align 16
+    .p2align 4,,15
+
+
+# define local variable storage offsets
+.equ	p_x,0			# save x
+.equ	p_idx,0x010		# xmmword index
+.equ	p_z1,0x020		# xmmword index
+.equ	p_q,0x030		# xmmword index
+.equ	p_corr,0x040		# xmmword index
+.equ	p_omask,0x050		# xmmword index
+
+
+.equ	p_x2,0x0100		# save x
+.equ	p_idx2,0x0110		# xmmword index
+.equ	p_z12,0x0120		# xmmword index
+.equ	p_q2,0x0130		# xmmword index
+
+.equ	save_xa,0x0140		#qword
+.equ	save_ya,0x0148		#qword
+.equ	save_nv,0x0150		#qword
+.equ	p_iter,0x0158		# qword	storage for number of loop iterations
+
+.equ	save_rbx,0x0160		#
+.equ	save_rdi,0x0168		#qword
+.equ	save_rsi,0x0170		#qword
+
+.equ	p2_temp,0x0180		#qword
+.equ	p2_temp1,0x01a0		#qword
+
+.equ	stack_size,0x01c8
+
+
+
+
+# parameters are passed in by gcc as:
+# rdi - int n
+# rsi - double *x
+# rdx - double *y
+
+.globl vrsa_log10f
+    .type   vrsa_log10f,@function
+vrsa_log10f:
+	sub		$stack_size,%rsp
+	mov		%rbx,save_rbx(%rsp)	# save rdi
+
+# save the arguments
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+	mov		%rdx,save_ya(%rsp)	# save y_array pointer
+#ifdef INTEGER64
+        mov             %rdi,%rax
+#else
+        mov             %edi,%eax
+        mov             %rax,%rdi
+#endif
+	mov		%rdi,save_nv(%rsp)	# save number of values
+# see if too few values to call the main loop
+	shr		$3,%rax						# get number of iterations
+	jz		.L__vsa_cleanup				# jump if only single calls
+# prepare the iteration counts
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	shl		$3,%rax
+	sub		%rax,%rdi						# compute number of extra single calls
+	mov		%rdi,save_nv(%rsp)	# save number of left over values
+
+# In this second version, process the array 8 values at a time.
+
+.L__vsa_top:
+# build the input _m128
+	mov		save_xa(%rsp),%rsi	# get x_array pointer
+	movups	(%rsi),%xmm0
+		movups	16(%rsi),%xmm12
+#	movhps	.LQWORD,%xmm0 PTR [rsi+8]
+	prefetch	64(%rsi)
+	add		$32,%rsi
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+
+
+# check e as a special case
+	movdqa	%xmm0,p_x(%rsp)	# save x
+		movdqa	%xmm12,p_x2(%rsp)	# save x
+	movdqa	%xmm0,%xmm2
+	cmpps	$0,.L__real_ef(%rip),%xmm2
+	movmskps	%xmm2,%r9d
+
+		movdqa	%xmm12,%xmm9
+		movaps	%xmm12,%xmm7
+
+#
+# compute the index into the log tables
+#
+	movdqa	%xmm0,%xmm3
+	movaps	%xmm0,%xmm1
+	psrld	$23,%xmm3
+
+	#
+	# compute the index into the log tables
+	#
+		psrld	$23,%xmm9
+		subps	.L__real_one(%rip),%xmm7
+		psubd	.L__mask_127(%rip),%xmm9
+	subps	.L__real_one(%rip),%xmm1
+	psubd	.L__mask_127(%rip),%xmm3
+		cvtdq2ps	%xmm9,%xmm13			# xexp
+
+		movdqa	%xmm12,%xmm9
+		pand	.L__real_mant(%rip),%xmm9
+		xor		%r8,%r8
+		movdqa	%xmm9,%xmm8
+		movaps	.L__real_half(%rip),%xmm11							# .5
+	cvtdq2ps	%xmm3,%xmm6			# xexp
+
+	movdqa	%xmm0,%xmm3
+	pand	.L__real_mant(%rip),%xmm3
+	xor		%r8,%r8
+	movdqa	%xmm3,%xmm2
+	movaps	.L__real_half(%rip),%xmm5							# .5
+
+#/* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+	psrld	$16,%xmm3
+	lea		.L__np_ln_lead_table(%rip),%rdx
+	movdqa	%xmm3,%xmm4
+		psrld	$16,%xmm9
+		movdqa	%xmm9,%xmm10
+		psrld	$1,%xmm9
+	psrld	$1,%xmm3
+	paddd	.L__mask_040(%rip),%xmm3
+	pand	.L__mask_001(%rip),%xmm4
+	paddd	%xmm4,%xmm3
+	cvtdq2ps	%xmm3,%xmm1
+	#/* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+		paddd	.L__mask_040(%rip),%xmm9
+		pand	.L__mask_001(%rip),%xmm10
+		paddd	%xmm10,%xmm9
+		cvtdq2ps	%xmm9,%xmm7
+	packssdw	%xmm3,%xmm3
+	movq	%xmm3,p_idx(%rsp)
+		packssdw	%xmm9,%xmm9
+		movq	%xmm9,p_idx2(%rsp)
+
+
+# reduce and get u
+	movdqa	%xmm0,%xmm3
+	orps		.L__real_half(%rip),%xmm2
+
+
+	mulps	.L__real_3c000000(%rip),%xmm1				# f1 = index/128
+	# reduce and get u
+
+
+	subps	%xmm1,%xmm2											# f2 = f - f1
+	mulps	%xmm2,%xmm5
+	addps	%xmm5,%xmm1
+
+	divps	%xmm1,%xmm2				# u
+
+		movdqa	%xmm12,%xmm9
+		orps		.L__real_half(%rip),%xmm8
+
+
+		mulps	.L__real_3c000000(%rip),%xmm7				# f1 = index/128
+		subps	%xmm7,%xmm8											# f2 = f - f1
+		mulps	%xmm8,%xmm11
+		addps	%xmm11,%xmm7
+
+
+        mov             p_idx(%rsp),%rcx                        # get the indexes
+        mov             %cx,%r8w
+        ror             $16,%rcx
+        mov             -256(%rdx,%r8,4),%eax           # get the f1 value
+
+        mov             %cx,%r8w
+        ror             $16,%rcx
+        mov             -256(%rdx,%r8,4),%ebx           # get the f1 value
+        shl             $32,%rbx
+        or              %rbx,%rax
+        mov              %rax,p_z1(%rsp)                        # save the f1 values
+
+
+        mov             %cx,%r8w
+        ror             $16,%rcx
+        mov             -256(%rdx,%r8,4),%eax           # get the f1 value
+
+        mov             %cx,%r8w
+        ror             $16,%rcx
+        or              -256(%rdx,%r8,4),%ebx           # get the f1 value
+        shl             $32,%rbx
+        or              %rbx,%rax
+        mov              %rax,p_z1+8(%rsp)                      # save the f1 value
+
+		divps	%xmm7,%xmm8				# u
+		lea		.L__np_ln_lead_table(%rip),%rdx
+                mov             p_idx2(%rsp),%rcx                       # get the indexes
+                mov             %cx,%r8w
+                ror             $16,%rcx
+                mov             -256(%rdx,%r8,4),%eax           # get the f1 value
+
+                mov             %cx,%r8w
+                ror             $16,%rcx
+                mov             -256(%rdx,%r8,4),%ebx           # get the f1 value
+                shl             $32,%rbx
+                or              %rbx,%rax
+                mov              %rax,p_z12(%rsp)                       # save the f1 values
+
+
+                mov             %cx,%r8w
+                ror             $16,%rcx
+                mov             -256(%rdx,%r8,4),%eax           # get the f1 value
+
+                mov             %cx,%r8w
+                ror             $16,%rcx
+                or              -256(%rdx,%r8,4),%ebx           # get the f1 value
+                shl             $32,%rbx
+                or              %rbx,%rax
+                mov              %rax,p_z12+8(%rsp)                     # save the f1 value
+
+# solve for ln(1+u)
+	movaps	%xmm2,%xmm1				# u
+	mulps	%xmm2,%xmm2				# u^2
+	movaps	%xmm2,%xmm5
+	movaps	.L__real_cb3(%rip),%xmm3
+	mulps	%xmm2,%xmm3				#Cu2
+	mulps	%xmm1,%xmm5				# u^3
+	addps	.L__real_cb2(%rip),%xmm3 #B+Cu2
+	movaps	%xmm2,%xmm4
+	mulps	%xmm5,%xmm4				# u^5
+	movaps	.L__real_log2_lead(%rip),%xmm2
+
+	mulps	.L__real_cb1(%rip),%xmm5 #Au3
+	addps	%xmm5,%xmm1				# u+Au3
+	mulps	%xmm3,%xmm4				# u5(B+Cu2)
+
+	lea		.L__np_ln_tail_table(%rip),%rdx
+	addps	%xmm4,%xmm1				# poly
+
+# recombine
+	mov		p_idx(%rsp),%rcx 			# get the indexes
+        mov             %cx,%r8w
+        shr             $16,%rcx
+        mov             -256(%rdx,%r8,4),%eax           # get the f2 value
+
+        mov             %cx,%r8w
+        shr             $16,%rcx
+        or              -256(%rdx,%r8,4),%ebx           # get the f2 value
+        shl             $32,%rbx
+        or              %rbx,%rax
+        mov              %rax,p_q(%rsp)                         # save the f2 value
+
+
+        mov             %cx,%r8w
+        shr             $16,%rcx
+        mov             -256(%rdx,%r8,4),%eax           # get the f2 value
+
+        mov             %cx,%r8w
+        mov             -256(%rdx,%r8,4),%ebx           # get the f2 value
+        shl             $32,%rbx
+        or              %rbx,%rax
+        mov              %rax,p_q+8(%rsp)                       # save the f2 value
+
+	addps	p_q(%rsp),%xmm1 #z2	+=q
+
+	movaps	p_z1(%rsp),%xmm0			# z1  values
+
+	mulps	%xmm6,%xmm2
+	addps	%xmm2,%xmm0				#r1
+	movaps	%xmm0,%xmm2
+	mulps	.L__real_log2_tail(%rip),%xmm6
+	addps	%xmm6,%xmm1				#r2
+	movaps	%xmm1,%xmm3
+
+#	logef to log10f
+	mulps 	.L__real_log10e_tail(%rip),%xmm1
+	mulps 	.L__real_log10e_tail(%rip),%xmm0
+	mulps 	.L__real_log10e_lead(%rip),%xmm3
+	mulps 	.L__real_log10e_lead(%rip),%xmm2
+	addps 	%xmm1,%xmm0
+	addps 	%xmm3,%xmm0
+	addps	%xmm2,%xmm0
+#	addps	%xmm1,%xmm0
+
+
+
+# check for e
+#	test		$0x0f,%r9d
+	#	jnz			.L__vlogf_e
+.L__f1:
+
+# check for negative numbers or zero
+	xorps	%xmm1,%xmm1
+	cmpps	$1,p_x(%rsp),%xmm1	# 0 greater than =?. catches NaNs also.
+	movmskps	%xmm1,%r9d
+	cmp		$0x0f,%r9d
+	jnz		.L__z_or_neg
+
+.L__f2:
+##  if +inf
+	movaps	p_x(%rsp),%xmm3
+	cmpps	$0,.L__real_inf(%rip),%xmm3
+	movmskps	%xmm3,%r9d
+	test		$0x0f,%r9d
+	jnz		.L__log_inf
+.L__f3:
+
+	movaps	p_x(%rsp),%xmm3
+	subps	.L__real_one(%rip),%xmm3
+	andps	.L__real_notsign(%rip),%xmm3
+	cmpps	$2,.L__real_threshold(%rip),%xmm3
+	movmskps	%xmm3,%r9d
+	test	$0x0f,%r9d
+	jnz		.L__near_one
+.L__f4:
+
+# store the result _m128d
+	mov		save_ya(%rsp),%rdi	# get y_array pointer
+	movups	%xmm0,(%rdi)
+
+# finish the second set of calculations
+
+	# solve for ln(1+u)
+		movaps	%xmm8,%xmm7				# u
+		mulps	%xmm8,%xmm8				# u^2
+		movaps	%xmm8,%xmm11
+
+		movaps	.L__real_cb3(%rip),%xmm9
+		mulps	%xmm8,%xmm9				#Cu2
+		mulps	%xmm7,%xmm11				# u^3
+		addps	.L__real_cb2(%rip),%xmm9 #B+Cu2
+		movaps	%xmm8,%xmm10
+		mulps	%xmm11,%xmm10				# u^5
+		movaps	.L__real_log2_lead(%rip),%xmm8
+
+		mulps	.L__real_cb1(%rip),%xmm11 #Au3
+		addps	%xmm11,%xmm7				# u+Au3
+		mulps	%xmm9,%xmm10				# u5(B+Cu2)
+		addps	%xmm10,%xmm7				# poly
+
+
+	# recombine
+		lea		.L__np_ln_tail_table(%rip),%rdx
+		mov		p_idx2(%rsp),%rcx 			# get the indexes
+		mov             %cx,%r8w
+                shr             $16,%rcx
+                mov             -256(%rdx,%r8,4),%eax           # get the f2 value
+
+                mov             %cx,%r8w
+                shr             $16,%rcx
+                or              -256(%rdx,%r8,4),%ebx           # get the f2 value
+                shl             $32,%rbx
+                or              %rbx,%rax
+                mov              %rax,p_q2(%rsp)                        # save the f2 value
+
+
+                mov             %cx,%r8w
+                shr             $16,%rcx
+                mov             -256(%rdx,%r8,4),%eax           # get the f2 value
+
+                mov             %cx,%r8w
+                mov             -256(%rdx,%r8,4),%ebx           # get the f2 value
+                shl             $32,%rbx
+                or              %rbx,%rax
+                mov              %rax,p_q2+8(%rsp)                      # save the f2 value
+
+                addps   p_q2(%rsp),%xmm7 #z2    +=q
+		movaps	p_z12(%rsp),%xmm1			# z1  values
+
+		mulps	%xmm13,%xmm8
+		addps	%xmm8,%xmm1				#r1
+		movaps	%xmm1,%xmm8
+		mulps	.L__real_log2_tail(%rip),%xmm13
+		addps	%xmm13,%xmm7				#r2
+		movaps	%xmm7,%xmm9
+	#	logef to log10f
+		mulps 	.L__real_log10e_tail(%rip),%xmm7
+		mulps 	.L__real_log10e_tail(%rip),%xmm1
+		mulps 	.L__real_log10e_lead(%rip),%xmm9
+		mulps 	.L__real_log10e_lead(%rip),%xmm8
+		addps 	%xmm7,%xmm1
+		addps 	%xmm9,%xmm1
+		addps	%xmm8,%xmm1
+#		addps	%xmm7,%xmm1
+
+	# check e as a special case
+#		movaps	p_x2(%rsp),%xmm10
+#		cmpps	$0,.L__real_ef(%rip),%xmm10
+#		movmskps	%xmm10,%r9d
+	# check for e
+#		test		$0x0f,%r9d
+#		jnz			.L__vlogf_e2
+.L__f12:
+
+	# check for negative numbers or zero
+		xorps	%xmm7,%xmm7
+		cmpps	$1,p_x2(%rsp),%xmm7	# 0 greater than =?. catches NaNs also.
+		movmskps	%xmm7,%r9d
+		cmp		$0x0f,%r9d
+		jnz		.L__z_or_neg2
+
+.L__f22:
+	##  if +inf
+		movaps	p_x2(%rsp),%xmm9
+		cmpps	$0,.L__real_inf(%rip),%xmm9
+		movmskps	%xmm9,%r9d
+		test		$0x0f,%r9d
+		jnz		.L__log_inf2
+.L__f32:
+
+		movaps	p_x2(%rsp),%xmm9
+		subps	.L__real_one(%rip),%xmm9
+		andps	.L__real_notsign(%rip),%xmm9
+		cmpps	$2,.L__real_threshold(%rip),%xmm9
+		movmskps	%xmm9,%r9d
+		test	$0x0f,%r9d
+		jnz		.L__near_one2
+.L__f42:
+
+
+	prefetch	64(%rsi)
+	add		$32,%rdi
+	mov		%rdi,save_ya(%rsp)	# save y_array pointer
+
+# store the result _m128d
+                movups  %xmm1,-16(%rdi)
+
+	mov		p_iter(%rsp),%rax	# get number of iterations
+	sub		$1,%rax
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	jnz		.L__vsa_top
+
+
+# see if we need to do any extras
+	mov		save_nv(%rsp),%rax	# get number of values
+	test	%rax,%rax
+	jnz		.L__vsa_cleanup
+
+
+#
+.L__final_check:
+	mov		save_rbx(%rsp),%rbx		# restore rbx
+	add		$stack_size,%rsp
+	ret
+
+
+
+	.align	16
+# we jump here when we have an odd number of log calls to make at the
+# end
+.L__vsa_cleanup:
+        mov             save_nv(%rsp),%rax      # get number of values
+        test            %rax,%rax               # are there any values
+        jz              .L__final_check         # exit if not
+
+	mov		save_xa(%rsp),%rsi
+	mov		save_ya(%rsp),%rdi
+
+# fill in a m128 with zeroes and the extra values and then make a recursive call.
+	xorps		%xmm0,%xmm0
+        movaps   %xmm0,p2_temp(%rsp)
+        movaps   %xmm0,p2_temp+16(%rsp)
+
+        mov             (%rsi),%ecx                     # we know there's at least one
+        mov             %ecx,p2_temp(%rsp)
+        cmp             $2,%rax
+        jl              .L__vsacg
+
+        mov             4(%rsi),%ecx                    # do the second value
+        mov             %ecx,p2_temp+4(%rsp)
+        cmp             $3,%rax
+        jl              .L__vsacg
+
+        mov             8(%rsi),%ecx                    # do the third value
+        mov             %ecx,p2_temp+8(%rsp)
+        cmp             $4,%rax
+        jl              .L__vsacg
+
+        mov             12(%rsi),%ecx                   # do the fourth value
+        mov             %ecx,p2_temp+12(%rsp)
+        cmp             $5,%rax
+        jl              .L__vsacg
+
+        mov             16(%rsi),%ecx                   # do the fifth value
+        mov             %ecx,p2_temp+16(%rsp)
+        cmp             $6,%rax
+        jl              .L__vsacg
+
+        mov             20(%rsi),%ecx                   # do the sixth value
+        mov             %ecx,p2_temp+20(%rsp)
+        cmp             $7,%rax
+        jl              .L__vsacg
+
+        mov             24(%rsi),%ecx                   # do the last value
+        mov             %ecx,p2_temp+24(%rsp)
+
+.L__vsacg:
+	mov		$8,%rdi				# parameter for N
+        lea             p2_temp(%rsp),%rsi      # &x parameter
+        lea             p2_temp1(%rsp),%rdx      # &y parameter
+        call		vrsa_log10f@PLT	# call recursively to compute four values
+
+# now copy the results to the destination array
+        mov             save_ya(%rsp),%rdi
+        mov             save_nv(%rsp),%rax      # get number of values
+        mov             p2_temp1(%rsp),%ecx
+        mov             %ecx,(%rdi)                     # we know there's at least one
+        cmp             $2,%rax
+        jl              .L__vsacgf
+
+        mov             p2_temp1+4(%rsp),%ecx
+        mov             %ecx,4(%rdi)                    # do the second value
+        cmp             $3,%rax
+        jl              .L__vsacgf
+
+        mov             p2_temp1+8(%rsp),%ecx
+        mov             %ecx,8(%rdi)                    # do the second value
+        cmp             $4,%rax
+        jl              .L__vsacgf
+
+        mov             p2_temp1+12(%rsp),%ecx
+        mov             %ecx,12(%rdi)                   # do the second value
+        cmp             $5,%rax
+        jl              .L__vsacgf
+
+        mov             p2_temp1+16(%rsp),%ecx
+        mov             %ecx,16(%rdi)                   # do the second value
+        cmp             $6,%rax
+        jl              .L__vsacgf
+
+        mov             p2_temp1+20(%rsp),%ecx
+        mov             %ecx,20(%rdi)                   # do the second value
+        cmp             $7,%rax
+        jl              .L__vsacgf
+
+        mov             p2_temp1+24(%rsp),%ecx
+        mov             %ecx,24(%rdi)                   # do the last value
+
+.L__vsacgf:
+	jmp		.L__final_check
+
+
+.L__vlogf_e:
+	movdqa	p_x(%rsp),%xmm2
+	cmpps	$0,.L__real_ef(%rip),%xmm2
+	movdqa	%xmm2,%xmm3
+	andnps	%xmm0,%xmm3							# keep the non-e values
+	andps	.L__real_one(%rip),%xmm2			# setup the 1 values
+	orps	%xmm3,%xmm2							# merge
+	movdqa	%xmm2,%xmm0							# and replace
+	jmp		.L__f1
+
+.L__vlogf_e2:
+		movdqa	p_x2(%rsp),%xmm2
+		cmpps	$0,.L__real_ef(%rip),%xmm2
+		movdqa	%xmm2,%xmm3
+		andnps	%xmm1,%xmm3							# keep the non-e values
+		andps	.L__real_one(%rip),%xmm2			# setup the 1 values
+		orps	%xmm3,%xmm2							# merge
+		movdqa	%xmm2,%xmm1							# and replace
+		jmp		.L__f12
+
+	.align	16
+.L__near_one:
+# saves 10 cycles
+#      r = x - 1.0;
+	movdqa	%xmm3,p_omask(%rsp)	# save ones mask
+	movaps	p_x(%rsp),%xmm3
+	movaps	.L__real_two(%rip),%xmm2
+	subps	.L__real_one(%rip),%xmm3	   # r
+#      u          = r / (2.0 + r);
+	addps	%xmm3,%xmm2
+	movaps	%xmm3,%xmm1
+	divps	%xmm2,%xmm1		# u
+	movaps	.L__real_ca4(%rip),%xmm4	  #D
+	movaps	.L__real_ca3(%rip),%xmm5	  #C
+#      correction = r * u;
+	movaps	%xmm3,%xmm6
+	mulps	%xmm1,%xmm6		# correction
+	movdqa	%xmm6,p_corr(%rsp)	# save correction
+#      u          = u + u;
+	addps	%xmm1,%xmm1		#u
+	movaps	%xmm1,%xmm2
+	mulps	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulps	%xmm1,%xmm5		# Cu
+	movaps	%xmm1,%xmm6
+	mulps	%xmm2,%xmm6		# u^3
+	mulps	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulps	%xmm6,%xmm4		#Du^3
+
+	addps	.L__real_ca1(%rip),%xmm2	# +A
+	movaps	%xmm6,%xmm1
+	mulps	%xmm1,%xmm1		# u^6
+	addps	%xmm4,%xmm5		#Cu+Du3
+
+	mulps	%xmm6,%xmm2		#u3(A+Bu2)
+	mulps	%xmm5,%xmm1		#u6(Cu+Du3)
+	addps	%xmm1,%xmm2
+	subps	p_corr(%rsp),%xmm2		# -correction
+#  loge to log10
+	movaps   %xmm3,%xmm5 	#r1=r
+	pand 	.L__mask_lower(%rip),%xmm5
+	subps	%xmm5,%xmm3
+	addps	%xmm3,%xmm2	#r2 = r2 + (r-r1)
+
+	movaps	%xmm5,%xmm3
+	movaps	%xmm2,%xmm1
+
+	mulps 	.L__real_log10e_tail(%rip),%xmm2
+	mulps 	.L__real_log10e_tail(%rip),%xmm3
+	mulps 	.L__real_log10e_lead(%rip),%xmm1
+	mulps 	.L__real_log10e_lead(%rip),%xmm5
+	addps 	%xmm2,%xmm3
+	addps 	%xmm1,%xmm3
+	addps	%xmm5,%xmm3
+#      return r + r2;
+#	addps	%xmm2,%xmm3
+
+	movdqa	p_omask(%rsp),%xmm6
+	movdqa	%xmm6,%xmm2
+	andnps	%xmm0,%xmm6					# keep the non-nearone values
+	andps	%xmm3,%xmm2					# setup the nearone values
+	orps	%xmm6,%xmm2					# merge
+	movdqa	%xmm2,%xmm0					# and replace
+
+	jmp		.L__f4
+
+
+	.align	16
+.L__near_one2:
+# saves 10 cycles
+#      r = x - 1.0;
+		movdqa	%xmm9,p_omask(%rsp)	# save ones mask
+		movaps	p_x2(%rsp),%xmm3
+		movaps	.L__real_two(%rip),%xmm2
+		subps	.L__real_one(%rip),%xmm3	   # r
+	#      u          = r / (2.0 + r);
+		addps	%xmm3,%xmm2
+		movaps	%xmm3,%xmm7
+		divps	%xmm2,%xmm7		# u
+		movaps	.L__real_ca4(%rip),%xmm4	  #D
+		movaps	.L__real_ca3(%rip),%xmm5	  #C
+	#      correction = r * u;
+		movaps	%xmm3,%xmm6
+		mulps	%xmm7,%xmm6		# correction
+		movdqa	%xmm6,p_corr(%rsp)	# save correction
+	#      u          = u + u;
+		addps	%xmm7,%xmm7		#u
+		movaps	%xmm7,%xmm2
+		mulps	%xmm2,%xmm2		#v =u^2
+	#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+		mulps	%xmm7,%xmm5		# Cu
+		movaps	%xmm7,%xmm6
+		mulps	%xmm2,%xmm6		# u^3
+		mulps	.L__real_ca2(%rip),%xmm2	#Bu^2
+		mulps	%xmm6,%xmm4		#Du^3
+
+		addps	.L__real_ca1(%rip),%xmm2	# +A
+		movaps	%xmm6,%xmm7
+		mulps	%xmm7,%xmm7		# u^6
+		addps	%xmm4,%xmm5		#Cu+Du3
+
+		mulps	%xmm6,%xmm2		#u3(A+Bu2)
+		mulps	%xmm5,%xmm7		#u6(Cu+Du3)
+		addps	%xmm7,%xmm2
+		subps	p_corr(%rsp),%xmm2		# -correction
+
+		#loge to log10
+		movaps   %xmm3,%xmm5 	#r1=r
+		pand 	.L__mask_lower(%rip),%xmm5
+		subps	%xmm5,%xmm3
+		addps	%xmm3,%xmm2	#r2 = r2 + (r-r1)
+
+		movaps	%xmm5,%xmm3
+		movaps	%xmm2,%xmm7
+
+		mulps 	.L__real_log10e_tail(%rip),%xmm2
+		mulps 	.L__real_log10e_tail(%rip),%xmm3
+		mulps 	.L__real_log10e_lead(%rip),%xmm7
+		mulps 	.L__real_log10e_lead(%rip),%xmm5
+		addps 	%xmm2,%xmm3
+		addps 	%xmm7,%xmm3
+		addps	%xmm5,%xmm3
+	#      return r + r2;
+#		addps	%xmm2,%xmm3
+
+		movdqa	p_omask(%rsp),%xmm6
+		movdqa	%xmm6,%xmm2
+		andnps	%xmm1,%xmm6					# keep the non-nearone values
+		andps	%xmm3,%xmm2					# setup the nearone values
+		orps	%xmm6,%xmm2					# merge
+		movdqa	%xmm2,%xmm1					# and replace
+
+		jmp		.L__f42
+
+# we have a zero, a negative number, or both.
+# the mask is already in .LNaNs,%xmm1 are also picked up here, along with -inf.
+.L__z_or_neg:
+# deal with negatives first
+	movdqa	%xmm1,%xmm3
+	andps	%xmm0,%xmm3							# keep the non-error values
+	andnps	.L__real_nan(%rip),%xmm1			# setup the nan values
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+# check for +/- 0
+	xorps	%xmm1,%xmm1
+	cmpps	$0,p_x(%rsp),%xmm1	# 0 ?.
+	movmskps	%xmm1,%r9d
+	test		$0x0f,%r9d
+	jz		.L__zn2
+
+	movdqa	%xmm1,%xmm3
+	andnps	%xmm0,%xmm3							# keep the non-error values
+	andps	.L__real_ninf(%rip),%xmm1		# ; C99 specs -inf for +-0
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+
+.L__zn2:
+# check for NaNs
+	movaps	p_x(%rsp),%xmm3
+	andps	.L__real_inf(%rip),%xmm3
+	cmpps	$0,.L__real_inf(%rip),%xmm3		# mask for max exponent
+
+	movdqa	p_x(%rsp),%xmm4
+	pand	.L__real_mant(%rip),%xmm4		# mask for non-zero mantissa
+	pcmpeqd	.L__real_zero(%rip),%xmm4
+	pandn	%xmm3,%xmm4							# mask for NaNs
+	movdqa	%xmm4,%xmm2
+	movdqa	p_x(%rsp),%xmm1			# isolate the NaNs
+	pand	%xmm4,%xmm1
+
+	pand	.L__real_qnanbit(%rip),%xmm4		# now we have a mask that will set QNaN bit
+	por		%xmm1,%xmm4							# turn SNaNs to QNaNs
+
+	movdqa	%xmm2,%xmm1
+	andnps	%xmm0,%xmm2							# keep the non-error values
+	orps	%xmm4,%xmm2							# merge
+	movdqa	%xmm2,%xmm0							# and replace
+	xorps	%xmm4,%xmm4
+
+	jmp		.L__f2
+
+# handle only +inf	 log(+inf) = inf
+.L__log_inf:
+	movdqa	%xmm3,%xmm1
+	andnps	%xmm0,%xmm3							# keep the non-error values
+	andps	p_x(%rsp),%xmm1			# setup the +inf values
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+	jmp		.L__f3
+
+
+.L__z_or_neg2:
+	# deal with negatives first
+		movdqa	%xmm7,%xmm3
+		andps	%xmm1,%xmm3							# keep the non-error values
+		andnps	.L__real_nan(%rip),%xmm7			# setup the nan values
+		orps	%xmm3,%xmm7							# merge
+		movdqa	%xmm7,%xmm1							# and replace
+	# check for +/- 0
+		xorps	%xmm7,%xmm7
+		cmpps	$0,p_x2(%rsp),%xmm7	# 0 ?.
+		movmskps	%xmm7,%r9d
+		test		$0x0f,%r9d
+		jz		.L__zn22
+
+		movdqa	%xmm7,%xmm3
+		andnps	%xmm1,%xmm3							# keep the non-error values
+		andps	.L__real_ninf(%rip),%xmm7		# ; C99 specs -inf for +-0
+		orps	%xmm3,%xmm7							# merge
+		movdqa	%xmm7,%xmm1							# and replace
+
+.L__zn22:
+	# check for NaNs
+		movaps	p_x2(%rsp),%xmm3
+		andps	.L__real_inf(%rip),%xmm3
+		cmpps	$0,.L__real_inf(%rip),%xmm3		# mask for max exponent
+
+		movdqa	p_x2(%rsp),%xmm4
+		pand	.L__real_mant(%rip),%xmm4		# mask for non-zero mantissa
+		pcmpeqd	.L__real_zero(%rip),%xmm4
+		pandn	%xmm3,%xmm4							# mask for NaNs
+		movdqa	%xmm4,%xmm2
+		movdqa	p_x2(%rsp),%xmm7			# isolate the NaNs
+		pand	%xmm4,%xmm7
+
+		pand	.L__real_qnanbit(%rip),%xmm4		# now we have a mask that will set QNaN bit
+		por		%xmm7,%xmm4							# turn SNaNs to QNaNs
+
+		movdqa	%xmm2,%xmm7
+		andnps	%xmm1,%xmm2							# keep the non-error values
+		orps	%xmm4,%xmm2							# merge
+		movdqa	%xmm2,%xmm1							# and replace
+		xorps	%xmm4,%xmm4
+
+		jmp		.L__f22
+
+	# handle only +inf	 log(+inf) = inf
+.L__log_inf2:
+		movdqa	%xmm9,%xmm7
+		andnps	%xmm1,%xmm9							# keep the non-error values
+		andps	p_x2(%rsp),%xmm7			# setup the +inf values
+		orps	%xmm9,%xmm7							# merge
+		movdqa	%xmm7,%xmm1							# and replace
+		jmp		.L__f32
+
+
+        .data
+        .align 64
+
+
+.L__real_zero:				.quad 0x00000000000000000	# 1.0
+					.quad 0x00000000000000000
+.L__real_one:				.quad 0x03f8000003f800000	# 1.0
+					.quad 0x03f8000003f800000
+.L__real_two:				.quad 0x04000000040000000	# 1.0
+					.quad 0x04000000040000000
+.L__real_ninf:				.quad 0x0ff800000ff800000	# -inf
+					.quad 0x0ff800000ff800000
+.L__real_inf:				.quad 0x07f8000007f800000	# +inf
+					.quad 0x07f8000007f800000
+.L__real_nan:				.quad 0x07fc000007fc00000	# NaN
+					.quad 0x07fc000007fc00000
+.L__real_ef:				.quad 0x0402DF854402DF854	# float e
+					.quad 0x0402DF854402DF854
+
+.L__real_sign:				.quad 0x08000000080000000	# sign bit
+					.quad 0x08000000080000000
+.L__real_notsign:			.quad 0x07ffFFFFF7ffFFFFF	# ^sign bit
+					.quad 0x07ffFFFFF7ffFFFFF
+.L__real_qnanbit:			.quad 0x00040000000400000	# quiet nan bit
+					.quad 0x00040000000400000
+.L__real_mant:				.quad 0x0007FFFFF007FFFFF	# mantipsa bits
+					.quad 0x0007FFFFF007FFFFF
+.L__real_3c000000:			.quad 0x03c0000003c000000	# /* 0.0078125 = 1/128 */
+					.quad 0x03c0000003c000000
+.L__mask_127:				.quad 0x00000007f0000007f	#
+					.quad 0x00000007f0000007f
+.L__mask_040:				.quad 0x00000004000000040	#
+					.quad 0x00000004000000040
+.L__mask_001:				.quad 0x00000000100000001	#
+					.quad 0x00000000100000001
+
+
+.L__real_threshold:			.quad 0x03CF5C28F3CF5C28F	# .03
+					.quad 0x03CF5C28F3CF5C28F
+
+.L__real_ca1:				.quad 0x03DAAAAAB3DAAAAAB	# 8.33333333333317923934e-02
+					.quad 0x03DAAAAAB3DAAAAAB
+.L__real_ca2:				.quad 0x03C4CCCCD3C4CCCCD	# 1.25000000037717509602e-02
+					.quad 0x03C4CCCCD3C4CCCCD
+.L__real_ca3:				.quad 0x03B1249183B124918	# 2.23213998791944806202e-03
+					.quad 0x03B1249183B124918
+.L__real_ca4:				.quad 0x039E401A639E401A6	# 4.34887777707614552256e-04
+					.quad 0x039E401A639E401A6
+.L__real_cb1:				.quad 0x03DAAAAAB3DAAAAAB	# 8.33333333333333593622e-02
+					.quad 0x03DAAAAAB3DAAAAAB
+.L__real_cb2:				.quad 0x03C4CCCCD3C4CCCCD	# 1.24999999978138668903e-02
+					.quad 0x03C4CCCCD3C4CCCCD
+.L__real_cb3:				.quad 0x03B124A123B124A12	# 2.23219810758559851206e-03
+					.quad 0x03B124A123B124A12
+.L__real_log2_lead:			.quad 0x03F3170003F317000  # 0.693115234375
+                        		.quad 0x03F3170003F317000
+.L__real_log2_tail:     		.quad 0x03805FDF43805FDF4  # 0.000031946183
+                       			.quad 0x03805FDF43805FDF4
+.L__real_half:				.quad 0x03f0000003f000000	# 1/2
+					.quad 0x03f0000003f000000
+
+.L__real_log10e_lead:	     .quad 0x03EDE00003EDE0000	# log10e_lead  0.4335937500
+                       .quad 0x03EDE00003EDE0000
+.L__real_log10e_tail:	      .quad 0x03A37B1523A37B152  # log10e_tail  0.0007007319
+                       .quad 0x03A37B1523A37B152
+
+
+.L__mask_lower:				.quad 0x0ffff0000ffff0000	#
+					.quad 0x0ffff0000ffff0000
+
+.L__np_ln__table:
+	.quad	0x0000000000000000 		# 0.00000000000000000000e+00
+	.quad	0x3F8FC0A8B0FC03E4		# 1.55041813850402832031e-02
+	.quad	0x3F9F829B0E783300		# 3.07716131210327148438e-02
+	.quad	0x3FA77458F632DCFC		# 4.58095073699951171875e-02
+	.quad	0x3FAF0A30C01162A6		# 6.06245994567871093750e-02
+	.quad	0x3FB341D7961BD1D1		# 7.52233862876892089844e-02
+	.quad	0x3FB6F0D28AE56B4C		# 8.96121263504028320312e-02
+	.quad	0x3FBA926D3A4AD563		# 1.03796780109405517578e-01
+	.quad	0x3FBE27076E2AF2E6		# 1.17783010005950927734e-01
+	.quad	0x3FC0D77E7CD08E59		# 1.31576299667358398438e-01
+	.quad	0x3FC29552F81FF523		# 1.45181953907012939453e-01
+	.quad	0x3FC44D2B6CCB7D1E		# 1.58604979515075683594e-01
+	.quad	0x3FC5FF3070A793D4		# 1.71850204467773437500e-01
+	.quad	0x3FC7AB890210D909		# 1.84922337532043457031e-01
+	.quad	0x3FC9525A9CF456B4		# 1.97825729846954345703e-01
+	.quad	0x3FCAF3C94E80BFF3		# 2.10564732551574707031e-01
+	.quad	0x3FCC8FF7C79A9A22		# 2.23143517971038818359e-01
+	.quad	0x3FCE27076E2AF2E6		# 2.35566020011901855469e-01
+	.quad	0x3FCFB9186D5E3E2B		# 2.47836112976074218750e-01
+	.quad	0x3FD0A324E27390E3		# 2.59957492351531982422e-01
+	.quad	0x3FD1675CABABA60E		# 2.71933674812316894531e-01
+	.quad	0x3FD22941FBCF7966		# 2.83768117427825927734e-01
+	.quad	0x3FD2E8E2BAE11D31		# 2.95464158058166503906e-01
+	.quad	0x3FD3A64C556945EA		# 3.07025015354156494141e-01
+	.quad	0x3FD4618BC21C5EC2		# 3.18453729152679443359e-01
+	.quad	0x3FD51AAD872DF82D		# 3.29753279685974121094e-01
+	.quad	0x3FD5D1BDBF5809CA		# 3.40926527976989746094e-01
+	.quad	0x3FD686C81E9B14AF		# 3.51976394653320312500e-01
+	.quad	0x3FD739D7F6BBD007		# 3.62905442714691162109e-01
+	.quad	0x3FD7EAF83B82AFC3		# 3.73716354370117187500e-01
+	.quad	0x3FD89A3386C1425B		# 3.84411692619323730469e-01
+	.quad	0x3FD947941C2116FB		# 3.94993782043457031250e-01
+	.quad	0x3FD9F323ECBF984C		# 4.05465066432952880859e-01
+	.quad	0x3FDA9CEC9A9A084A		# 4.15827870368957519531e-01
+	.quad	0x3FDB44F77BCC8F63		# 4.26084339618682861328e-01
+	.quad	0x3FDBEB4D9DA71B7C		# 4.36236739158630371094e-01
+	.quad	0x3FDC8FF7C79A9A22		# 4.46287095546722412109e-01
+	.quad	0x3FDD32FE7E00EBD5		# 4.56237375736236572266e-01
+	.quad	0x3FDDD46A04C1C4A1		# 4.66089725494384765625e-01
+	.quad	0x3FDE744261D68788		# 4.75845873355865478516e-01
+	.quad	0x3FDF128F5FAF06ED		# 4.85507786273956298828e-01
+	.quad	0x3FDFAF588F78F31F		# 4.95077252388000488281e-01
+	.quad	0x3FE02552A5A5D0FF		# 5.04556000232696533203e-01
+	.quad	0x3FE0723E5C1CDF40		# 5.13945698738098144531e-01
+	.quad	0x3FE0BE72E4252A83		# 5.23248136043548583984e-01
+	.quad	0x3FE109F39E2D4C97		# 5.32464742660522460938e-01
+	.quad	0x3FE154C3D2F4D5EA		# 5.41597247123718261719e-01
+	.quad	0x3FE19EE6B467C96F		# 5.50647079944610595703e-01
+	.quad	0x3FE1E85F5E7040D0		# 5.59615731239318847656e-01
+	.quad	0x3FE23130D7BEBF43		# 5.68504691123962402344e-01
+	.quad	0x3FE2795E1289B11B		# 5.77315330505371093750e-01
+	.quad	0x3FE2C0E9ED448E8C		# 5.86049020290374755859e-01
+	.quad	0x3FE307D7334F10BE		# 5.94707071781158447266e-01
+	.quad	0x3FE34E289D9CE1D3		# 6.03290796279907226562e-01
+	.quad	0x3FE393E0D3562A1A		# 6.11801505088806152344e-01
+	.quad	0x3FE3D9026A7156FB		# 6.20240390300750732422e-01
+	.quad	0x3FE41D8FE84672AE		# 6.28608644008636474609e-01
+	.quad	0x3FE4618BC21C5EC2		# 6.36907458305358886719e-01
+	.quad	0x3FE4A4F85DB03EBB		# 6.45137906074523925781e-01
+	.quad	0x3FE4E7D811B75BB1		# 6.53301239013671875000e-01
+	.quad	0x3FE52A2D265BC5AB		# 6.61398470401763916016e-01
+	.quad	0x3FE56BF9D5B3F399		# 6.69430613517761230469e-01
+	.quad	0x3FE5AD404C359F2D		# 6.77398800849914550781e-01
+	.quad	0x3FE5EE02A9241675		# 6.85303986072540283203e-01
+	.quad	0x3FE62E42FEFA39EF		# 6.93147122859954833984e-01
+	.quad 0					# for alignment
+
+.L__np_ln_lead_table:
+    .long 0x00000000  # 0.000000000000 0
+    .long 0x3C7E0000  # 0.015502929688 1
+    .long 0x3CFC1000  # 0.030769348145 2
+    .long 0x3D3BA000  # 0.045806884766 3
+    .long 0x3D785000  # 0.060623168945 4
+    .long 0x3D9A0000  # 0.075195312500 5
+    .long 0x3DB78000  # 0.089599609375 6
+    .long 0x3DD49000  # 0.103790283203 7
+    .long 0x3DF13000  # 0.117767333984 8
+    .long 0x3E06B000  # 0.131530761719 9
+    .long 0x3E14A000  # 0.145141601563 10
+    .long 0x3E226000  # 0.158569335938 11
+    .long 0x3E2FF000  # 0.171813964844 12
+    .long 0x3E3D5000  # 0.184875488281 13
+    .long 0x3E4A9000  # 0.197814941406 14
+    .long 0x3E579000  # 0.210510253906 15
+    .long 0x3E647000  # 0.223083496094 16
+    .long 0x3E713000  # 0.235534667969 17
+    .long 0x3E7DC000  # 0.247802734375 18
+    .long 0x3E851000  # 0.259887695313 19
+    .long 0x3E8B3000  # 0.271850585938 20
+    .long 0x3E914000  # 0.283691406250 21
+    .long 0x3E974000  # 0.295410156250 22
+    .long 0x3E9D3000  # 0.307006835938 23
+    .long 0x3EA30000  # 0.318359375000 24
+    .long 0x3EA8D000  # 0.329711914063 25
+    .long 0x3EAE8000  # 0.340820312500 26
+    .long 0x3EB43000  # 0.351928710938 27
+    .long 0x3EB9C000  # 0.362792968750 28
+    .long 0x3EBF5000  # 0.373657226563 29
+    .long 0x3EC4D000  # 0.384399414063 30
+    .long 0x3ECA3000  # 0.394897460938 31
+    .long 0x3ECF9000  # 0.405395507813 32
+    .long 0x3ED4E000  # 0.415771484375 33
+    .long 0x3EDA2000  # 0.426025390625 34
+    .long 0x3EDF5000  # 0.436157226563 35
+    .long 0x3EE47000  # 0.446166992188 36
+    .long 0x3EE99000  # 0.456176757813 37
+    .long 0x3EEEA000  # 0.466064453125 38
+    .long 0x3EF3A000  # 0.475830078125 39
+    .long 0x3EF89000  # 0.485473632813 40
+    .long 0x3EFD7000  # 0.494995117188 41
+    .long 0x3F012000  # 0.504394531250 42
+    .long 0x3F039000  # 0.513916015625 43
+    .long 0x3F05F000  # 0.523193359375 44
+    .long 0x3F084000  # 0.532226562500 45
+    .long 0x3F0AA000  # 0.541503906250 46
+    .long 0x3F0CF000  # 0.550537109375 47
+    .long 0x3F0F4000  # 0.559570312500 48
+    .long 0x3F118000  # 0.568359375000 49
+    .long 0x3F13C000  # 0.577148437500 50
+    .long 0x3F160000  # 0.585937500000 51
+    .long 0x3F183000  # 0.594482421875 52
+    .long 0x3F1A7000  # 0.603271484375 53
+    .long 0x3F1C9000  # 0.611572265625 54
+    .long 0x3F1EC000  # 0.620117187500 55
+    .long 0x3F20E000  # 0.628417968750 56
+    .long 0x3F230000  # 0.636718750000 57
+    .long 0x3F252000  # 0.645019531250 58
+    .long 0x3F273000  # 0.653076171875 59
+    .long 0x3F295000  # 0.661376953125 60
+    .long 0x3F2B5000  # 0.669189453125 61
+    .long 0x3F2D6000  # 0.677246093750 62
+    .long 0x3F2F7000  # 0.685302734375 63
+    .long 0x3F317000  # 0.693115234375 64
+    .long 0					# for alignment
+
+.L__np_ln_tail_table:
+    .long 0x00000000  # 0.000000000000 0
+    .long 0x35A8B0FC  # 0.000001256848 1
+    .long 0x361B0E78  # 0.000002310522 2
+    .long 0x3631EC66  # 0.000002651266 3
+    .long 0x35C30046  # 0.000001452871 4
+    .long 0x37EBCB0E  # 0.000028108738 5
+    .long 0x37528AE5  # 0.000012549314 6
+    .long 0x36DA7496  # 0.000006510479 7
+    .long 0x3783B715  # 0.000015701671 8
+    .long 0x383F3E68  # 0.000045596069 9
+    .long 0x38297C10  # 0.000040408282 10
+    .long 0x3815B666  # 0.000035694240 11
+    .long 0x38183854  # 0.000036292084 12
+    .long 0x38448108  # 0.000046850211 13
+    .long 0x373539E9  # 0.000010801924 14
+    .long 0x3864A740  # 0.000054515200 15
+    .long 0x387BE3CD  # 0.000060055219 16
+    .long 0x3803B715  # 0.000031403342 17
+    .long 0x380C36AF  # 0.000033429529 18
+    .long 0x3892713A  # 0.000069829126 19
+    .long 0x38AE55D6  # 0.000083129547 20
+    .long 0x38A0FDE8  # 0.000076766883 21
+    .long 0x3862BAE1  # 0.000054056643 22
+    .long 0x3798AAD3  # 0.000018199358 23
+    .long 0x38C5E10E  # 0.000094356117 24
+    .long 0x382D872E  # 0.000041372310 25
+    .long 0x38DEDFAC  # 0.000106274470 26
+    .long 0x38481E9B  # 0.000047712219 27
+    .long 0x38EBFB5E  # 0.000112524940 28
+    .long 0x38783B83  # 0.000059183232 29
+    .long 0x374E1B05  # 0.000012284848 30
+    .long 0x38CA0E11  # 0.000096347307 31
+    .long 0x3891F660  # 0.000069600297 32
+    .long 0x386C9A9A  # 0.000056410769 33
+    .long 0x38777BCD  # 0.000059004688 34
+    .long 0x38A6CED4  # 0.000079540216 35
+    .long 0x38FBE3CD  # 0.000120110439 36
+    .long 0x387E7E01  # 0.000060675669 37
+    .long 0x37D40984  # 0.000025276800 38
+    .long 0x3784C3AD  # 0.000015826745 39
+    .long 0x380F5FAF  # 0.000034182969 40
+    .long 0x38AC47BC  # 0.000082149607 41
+    .long 0x392952D3  # 0.000161479504 42
+    .long 0x37F97073  # 0.000029735476 43
+    .long 0x3865C84A  # 0.000054784388 44
+    .long 0x3979CF17  # 0.000238236375 45
+    .long 0x38C3D2F5  # 0.000093376184 46
+    .long 0x38E6B468  # 0.000110008579 47
+    .long 0x383EBCE1  # 0.000045475437 48
+    .long 0x39186BDF  # 0.000145360347 49
+    .long 0x392F0945  # 0.000166927537 50
+    .long 0x38E9ED45  # 0.000111545007 51
+    .long 0x396B99A8  # 0.000224685878 52
+    .long 0x37A27674  # 0.000019367064 53
+    .long 0x397069AB  # 0.000229275480 54
+    .long 0x39013539  # 0.000123222257 55
+    .long 0x3947F423  # 0.000190690669 56
+    .long 0x3945E10E  # 0.000188712234 57
+    .long 0x38F85DB0  # 0.000118430122 58
+    .long 0x396C08DC  # 0.000225100142 59
+    .long 0x37B4996F  # 0.000021529120 60
+    .long 0x397CEADA  # 0.000241200818 61
+    .long 0x3920261B  # 0.000152729845 62
+    .long 0x35AA4906  # 0.000001268724 63
+    .long 0x3805FDF4  # 0.000031946183 64
+    .long 0					# for alignment
+
diff --git a/src/gas/vrsalog2f.S b/src/gas/vrsalog2f.S
new file mode 100644
index 0000000..9760d9f
--- /dev/null
+++ b/src/gas/vrsalog2f.S
@@ -0,0 +1,1140 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrsalog2f.s
+#
+# An array implementation of the logf libm function.
+#
+# Prototype:
+#
+#    void vrsa_log2f(int n, float *x, float *y);
+#
+#   Computes the natural log of x.
+#   Places the results into the supplied y array.
+# Does not perform error handling, but does return C99 values for error
+# inputs.   Denormal results are truncated to 0.
+
+# This array version is basically a unrolling of the by4 scalar single
+# routine.  The second set of operations is performed by the indented
+# instructions interleaved into the first set.
+#
+#
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+       .weak vrsa_log2f_
+       .set vrsa_log2f_,__vrsa_log2f__
+       .weak vrsa_log2f__
+       .set vrsa_log2f__,__vrsa_log2f__
+
+    .text
+    .align 16
+    .p2align 4,,15
+
+#/* a FORTRAN subroutine implementation of array logf
+#**     VRSA_LOG2F(N,X,Y)
+# C equivalent*/
+#void vrsa_log2f__(int * n, float *x, float *y)
+#{
+#       vrsa_log2f(*n,x,y);
+#}
+.globl __vrsa_log2f__
+    .type   __vrsa_log2f__,@function
+__vrsa_log2f__:
+    mov         (%rdi),%edi
+
+    .align 16
+    .p2align 4,,15
+
+
+# define local variable storage offsets
+.equ	p_x,0			# save x
+.equ	p_idx,0x010		# xmmword index
+.equ	p_z1,0x020		# xmmword index
+.equ	p_q,0x030		# xmmword index
+.equ	p_corr,0x040		# xmmword index
+.equ	p_omask,0x050		# xmmword index
+
+
+.equ	p_x2,0x0100		# save x
+.equ	p_idx2,0x0110		# xmmword index
+.equ	p_z12,0x0120		# xmmword index
+.equ	p_q2,0x0130		# xmmword index
+
+.equ	save_xa,0x0140		#qword
+.equ	save_ya,0x0148		#qword
+.equ	save_nv,0x0150		#qword
+.equ	p_iter,0x0158		# qword	storage for number of loop iterations
+
+.equ	save_rbx,0x0160		#
+.equ	save_rdi,0x0168		#qword
+.equ	save_rsi,0x0170		#qword
+
+.equ	p2_temp,0x0180		#qword
+.equ	p2_temp1,0x01a0		#qword
+
+.equ	stack_size,0x01c8
+
+
+
+
+# parameters are passed in by gcc as:
+# rdi - int n
+# rsi - double *x
+# rdx - double *y
+
+.globl vrsa_log2f
+    .type   vrsa_log2f,@function
+vrsa_log2f:
+	sub		$stack_size,%rsp
+	mov		%rbx,save_rbx(%rsp)	# save rdi
+
+# save the arguments
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+	mov		%rdx,save_ya(%rsp)	# save y_array pointer
+#ifdef INTEGER64
+        mov             %rdi,%rax
+#else
+        mov             %edi,%eax
+        mov             %rax,%rdi
+#endif
+	mov		%rdi,save_nv(%rsp)	# save number of values
+# see if too few values to call the main loop
+	shr		$3,%rax						# get number of iterations
+	jz		.L__vsa_cleanup				# jump if only single calls
+# prepare the iteration counts
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	shl		$3,%rax
+	sub		%rax,%rdi						# compute number of extra single calls
+	mov		%rdi,save_nv(%rsp)	# save number of left over values
+
+# In this second version, process the array 8 values at a time.
+
+.L__vsa_top:
+# build the input _m128
+	mov		save_xa(%rsp),%rsi	# get x_array pointer
+	movups	(%rsi),%xmm0
+		movups	16(%rsi),%xmm12
+#	movhps	.LQWORD,%xmm0 PTR [rsi+8]
+	prefetch	64(%rsi)
+	add		$32,%rsi
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+
+
+# check e as a special case
+	movdqa	%xmm0,p_x(%rsp)	# save x
+		movdqa	%xmm12,p_x2(%rsp)	# save x
+	movdqa	%xmm0,%xmm2
+	cmpps	$0,.L__real_ef(%rip),%xmm2
+	movmskps	%xmm2,%r9d
+
+		movdqa	%xmm12,%xmm9
+		movaps	%xmm12,%xmm7
+
+#
+# compute the index into the log tables
+#
+	movdqa	%xmm0,%xmm3
+	movaps	%xmm0,%xmm1
+	psrld	$23,%xmm3
+
+	#
+	# compute the index into the log tables
+	#
+		psrld	$23,%xmm9
+		subps	.L__real_one(%rip),%xmm7
+		psubd	.L__mask_127(%rip),%xmm9
+	subps	.L__real_one(%rip),%xmm1
+	psubd	.L__mask_127(%rip),%xmm3
+		cvtdq2ps	%xmm9,%xmm13			# xexp
+
+		movdqa	%xmm12,%xmm9
+		pand	.L__real_mant(%rip),%xmm9
+		xor		%r8,%r8
+		movdqa	%xmm9,%xmm8
+		movaps	.L__real_half(%rip),%xmm11							# .5
+	cvtdq2ps	%xmm3,%xmm6			# xexp
+
+	movdqa	%xmm0,%xmm3
+	pand	.L__real_mant(%rip),%xmm3
+	xor		%r8,%r8
+	movdqa	%xmm3,%xmm2
+	movaps	.L__real_half(%rip),%xmm5							# .5
+
+#/* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+	psrld	$16,%xmm3
+	lea		.L__np_ln_lead_table(%rip),%rdx
+	movdqa	%xmm3,%xmm4
+		psrld	$16,%xmm9
+		movdqa	%xmm9,%xmm10
+		psrld	$1,%xmm9
+	psrld	$1,%xmm3
+	paddd	.L__mask_040(%rip),%xmm3
+	pand	.L__mask_001(%rip),%xmm4
+	paddd	%xmm4,%xmm3
+	cvtdq2ps	%xmm3,%xmm1
+	#/* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+		paddd	.L__mask_040(%rip),%xmm9
+		pand	.L__mask_001(%rip),%xmm10
+		paddd	%xmm10,%xmm9
+		cvtdq2ps	%xmm9,%xmm7
+	packssdw	%xmm3,%xmm3
+	movq	%xmm3,p_idx(%rsp)
+		packssdw	%xmm9,%xmm9
+		movq	%xmm9,p_idx2(%rsp)
+
+
+# reduce and get u
+	movdqa	%xmm0,%xmm3
+	orps		.L__real_half(%rip),%xmm2
+
+
+	mulps	.L__real_3c000000(%rip),%xmm1				# f1 = index/128
+	# reduce and get u
+
+
+	subps	%xmm1,%xmm2											# f2 = f - f1
+	mulps	%xmm2,%xmm5
+	addps	%xmm5,%xmm1
+
+	divps	%xmm1,%xmm2				# u
+
+		movdqa	%xmm12,%xmm9
+		orps		.L__real_half(%rip),%xmm8
+
+
+		mulps	.L__real_3c000000(%rip),%xmm7				# f1 = index/128
+		subps	%xmm7,%xmm8											# f2 = f - f1
+		mulps	%xmm8,%xmm11
+		addps	%xmm11,%xmm7
+
+
+        mov             p_idx(%rsp),%rcx                        # get the indexes
+        mov             %cx,%r8w
+        ror             $16,%rcx
+        mov             -256(%rdx,%r8,4),%eax           # get the f1 value
+
+        mov             %cx,%r8w
+        ror             $16,%rcx
+        mov             -256(%rdx,%r8,4),%ebx           # get the f1 value
+        shl             $32,%rbx
+        or              %rbx,%rax
+        mov              %rax,p_z1(%rsp)                        # save the f1 values
+
+
+        mov             %cx,%r8w
+        ror             $16,%rcx
+        mov             -256(%rdx,%r8,4),%eax           # get the f1 value
+
+        mov             %cx,%r8w
+        ror             $16,%rcx
+        or              -256(%rdx,%r8,4),%ebx           # get the f1 value
+        shl             $32,%rbx
+        or              %rbx,%rax
+        mov              %rax,p_z1+8(%rsp)                      # save the f1 value
+
+		divps	%xmm7,%xmm8				# u
+		lea		.L__np_ln_lead_table(%rip),%rdx
+                mov             p_idx2(%rsp),%rcx                       # get the indexes
+                mov             %cx,%r8w
+                ror             $16,%rcx
+                mov             -256(%rdx,%r8,4),%eax           # get the f1 value
+
+                mov             %cx,%r8w
+                ror             $16,%rcx
+                mov             -256(%rdx,%r8,4),%ebx           # get the f1 value
+                shl             $32,%rbx
+                or              %rbx,%rax
+                mov              %rax,p_z12(%rsp)                       # save the f1 values
+
+
+                mov             %cx,%r8w
+                ror             $16,%rcx
+                mov             -256(%rdx,%r8,4),%eax           # get the f1 value
+
+                mov             %cx,%r8w
+                ror             $16,%rcx
+                or              -256(%rdx,%r8,4),%ebx           # get the f1 value
+                shl             $32,%rbx
+                or              %rbx,%rax
+                mov              %rax,p_z12+8(%rsp)                     # save the f1 value
+
+# solve for ln(1+u)
+	movaps	%xmm2,%xmm1				# u
+	mulps	%xmm2,%xmm2				# u^2
+	movaps	%xmm2,%xmm5
+	movaps	.L__real_cb3(%rip),%xmm3
+	mulps	%xmm2,%xmm3				#Cu2
+	mulps	%xmm1,%xmm5				# u^3
+	addps	.L__real_cb2(%rip),%xmm3 #B+Cu2
+	movaps	%xmm2,%xmm4
+	mulps	%xmm5,%xmm4				# u^5
+	movaps	.L__real_log2e_lead(%rip),%xmm2
+
+	mulps	.L__real_cb1(%rip),%xmm5 #Au3
+	addps	%xmm5,%xmm1				# u+Au3
+	mulps	%xmm3,%xmm4				# u5(B+Cu2)
+	movaps	.L__real_log2e_tail(%rip),%xmm3
+	lea		.L__np_ln_tail_table(%rip),%rdx
+	addps	%xmm4,%xmm1				# poly
+
+# recombine
+	mov		p_idx(%rsp),%rcx 			# get the indexes
+        mov             %cx,%r8w
+        shr             $16,%rcx
+        mov             -256(%rdx,%r8,4),%eax           # get the f2 value
+
+        mov             %cx,%r8w
+        shr             $16,%rcx
+        or              -256(%rdx,%r8,4),%ebx           # get the f2 value
+        shl             $32,%rbx
+        or              %rbx,%rax
+        mov              %rax,p_q(%rsp)                         # save the f2 value
+
+
+        mov             %cx,%r8w
+        shr             $16,%rcx
+        mov             -256(%rdx,%r8,4),%eax           # get the f2 value
+
+        mov             %cx,%r8w
+        mov             -256(%rdx,%r8,4),%ebx           # get the f2 value
+        shl             $32,%rbx
+        or              %rbx,%rax
+        mov              %rax,p_q+8(%rsp)                       # save the f2 value
+
+	addps	p_q(%rsp),%xmm1 #z2	+=q
+	movaps	%xmm1,%xmm4	#z2 copy
+	movaps	p_z1(%rsp),%xmm0			# z1  values
+	movaps	%xmm0,%xmm5	#z1 copy
+
+	mulps	%xmm2,%xmm5	#z1*log2e_lead
+	mulps	%xmm2,%xmm1	#z2*log2e_lead
+	mulps	%xmm3,%xmm4	#z2*log2e_tail
+	mulps	%xmm3,%xmm0	#z1*log2e_tail
+	addps	%xmm6,%xmm5	#r1 = z1*log2e_lead + xexp
+	addps	%xmm4,%xmm0	#z1*log2e_tail + z2*log2e_tail
+	addps	%xmm1,%xmm0	#r2
+#return r1+r2
+	addps 	%xmm5,%xmm0	# r1+ r2
+
+
+# check for e
+#	test		$0x0f,%r9d
+#	jnz			.L__vlogf_e
+.L__f1:
+
+# check for negative numbers or zero
+	xorps	%xmm1,%xmm1
+	cmpps	$1,p_x(%rsp),%xmm1	# 0 greater than =?. catches NaNs also.
+	movmskps	%xmm1,%r9d
+	cmp		$0x0f,%r9d
+	jnz		.L__z_or_neg
+
+.L__f2:
+###  if +inf
+	movaps	p_x(%rsp),%xmm3
+	cmpps	$0,.L__real_inf(%rip),%xmm3
+	movmskps	%xmm3,%r9d
+	test		$0x0f,%r9d
+	jnz		.L__log_inf
+.L__f3:
+
+	movaps	p_x(%rsp),%xmm3
+	subps	.L__real_one(%rip),%xmm3
+	andps	.L__real_notsign(%rip),%xmm3
+	cmpps	$2,.L__real_threshold(%rip),%xmm3
+	movmskps	%xmm3,%r9d
+	test	$0x0f,%r9d
+	jnz		.L__near_one
+.L__f4:
+
+# store the result _m128d
+	mov		save_ya(%rsp),%rdi	# get y_array pointer
+	movups	%xmm0,(%rdi)
+
+# finish the second set of calculations
+
+	# solve for ln(1+u)
+		movaps	%xmm8,%xmm7				# u
+		mulps	%xmm8,%xmm8				# u^2
+		movaps	%xmm8,%xmm11
+
+		movaps	.L__real_cb3(%rip),%xmm9
+		mulps	%xmm8,%xmm9				#Cu2
+		mulps	%xmm7,%xmm11				# u^3
+		addps	.L__real_cb2(%rip),%xmm9 #B+Cu2
+		movaps	%xmm8,%xmm10
+		mulps	%xmm11,%xmm10				# u^5
+		movaps	.L__real_log2e_lead(%rip),%xmm8
+
+		mulps	.L__real_cb1(%rip),%xmm11 #Au3
+		addps	%xmm11,%xmm7				# u+Au3
+		mulps	%xmm9,%xmm10				# u5(B+Cu2)
+		movaps	.L__real_log2e_tail(%rip),%xmm9
+		addps	%xmm10,%xmm7				# poly
+
+
+	# recombine
+		lea		.L__np_ln_tail_table(%rip),%rdx
+		mov		p_idx2(%rsp),%rcx 			# get the indexes
+		mov             %cx,%r8w
+                shr             $16,%rcx
+                mov             -256(%rdx,%r8,4),%eax           # get the f2 value
+
+                mov             %cx,%r8w
+                shr             $16,%rcx
+                or              -256(%rdx,%r8,4),%ebx           # get the f2 value
+                shl             $32,%rbx
+                or              %rbx,%rax
+                mov              %rax,p_q2(%rsp)                        # save the f2 value
+
+
+                mov             %cx,%r8w
+                shr             $16,%rcx
+                mov             -256(%rdx,%r8,4),%eax           # get the f2 value
+
+                mov             %cx,%r8w
+                mov             -256(%rdx,%r8,4),%ebx           # get the f2 value
+                shl             $32,%rbx
+                or              %rbx,%rax
+                mov              %rax,p_q2+8(%rsp)                      # save the f2 value
+
+		addps	p_q2(%rsp),%xmm7 #z2	+=q
+		movaps	%xmm7,%xmm10	#z2 copy
+		movaps	p_z12(%rsp),%xmm1			# z1  values
+		movaps	%xmm1,%xmm11	#z1 copy
+
+		mulps	%xmm8,%xmm11	#z1*log2e_lead
+		mulps	%xmm8,%xmm7	#z2*log2e_lead
+		mulps	%xmm9,%xmm10	#z2*log2e_tail
+		mulps	%xmm9,%xmm1	#z1*log2e_tail
+		addps	%xmm13,%xmm11	#r1 = z1*log2e_lead + xexp
+		addps	%xmm10,%xmm1	#z1*log2e_tail + z2*log2e_tail
+		addps	%xmm7,%xmm1	#r2
+		#return r1+r2
+		addps 	%xmm11,%xmm1	# r1+ r2
+
+	# check e as a special case
+#		movaps	p_x2(%rsp),%xmm10
+#		cmpps	$0,.L__real_ef(%rip),%xmm10
+#		movmskps	%xmm10,%r9d
+	# check for e
+#		test		$0x0f,%r9d
+#		jnz			.L__vlogf_e2
+.L__f12:
+
+	# check for negative numbers or zero
+		xorps	%xmm7,%xmm7
+		cmpps	$1,p_x2(%rsp),%xmm7	# 0 greater than =?. catches NaNs also.
+		movmskps	%xmm7,%r9d
+		cmp		$0x0f,%r9d
+		jnz		.L__z_or_neg2
+
+.L__f22:
+	###  if +inf
+		movaps	p_x2(%rsp),%xmm9
+		cmpps	$0,.L__real_inf(%rip),%xmm9
+		movmskps	%xmm9,%r9d
+		test		$0x0f,%r9d
+		jnz		.L__log_inf2
+.L__f32:
+
+		movaps	p_x2(%rsp),%xmm9
+		subps	.L__real_one(%rip),%xmm9
+		andps	.L__real_notsign(%rip),%xmm9
+		cmpps	$2,.L__real_threshold(%rip),%xmm9
+		movmskps	%xmm9,%r9d
+		test	$0x0f,%r9d
+		jnz		.L__near_one2
+.L__f42:
+
+
+	prefetch	64(%rsi)
+	add		$32,%rdi
+	mov		%rdi,save_ya(%rsp)	# save y_array pointer
+
+# store the result _m128d
+                movups  %xmm1,-16(%rdi)
+
+	mov		p_iter(%rsp),%rax	# get number of iterations
+	sub		$1,%rax
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	jnz		.L__vsa_top
+
+
+# see if we need to do any extras
+	mov		save_nv(%rsp),%rax	# get number of values
+	test	%rax,%rax
+	jnz		.L__vsa_cleanup
+
+
+#
+.L__final_check:
+	mov		save_rbx(%rsp),%rbx		# restore rbx
+	add		$stack_size,%rsp
+	ret
+
+
+
+	.align	16
+# we jump here when we have an odd number of log calls to make at the
+# end
+.L__vsa_cleanup:
+        mov             save_nv(%rsp),%rax      # get number of values
+        test            %rax,%rax               # are there any values
+        jz              .L__final_check         # exit if not
+
+	mov		save_xa(%rsp),%rsi
+	mov		save_ya(%rsp),%rdi
+
+# fill in a m128 with zeroes and the extra values and then make a recursive call.
+	xorps		%xmm0,%xmm0
+        movaps   %xmm0,p2_temp(%rsp)
+        movaps   %xmm0,p2_temp+16(%rsp)
+
+        mov             (%rsi),%ecx                     # we know there's at least one
+        mov             %ecx,p2_temp(%rsp)
+        cmp             $2,%rax
+        jl              .L__vsacg
+
+        mov             4(%rsi),%ecx                    # do the second value
+        mov             %ecx,p2_temp+4(%rsp)
+        cmp             $3,%rax
+        jl              .L__vsacg
+
+        mov             8(%rsi),%ecx                    # do the third value
+        mov             %ecx,p2_temp+8(%rsp)
+        cmp             $4,%rax
+        jl              .L__vsacg
+
+        mov             12(%rsi),%ecx                   # do the fourth value
+        mov             %ecx,p2_temp+12(%rsp)
+        cmp             $5,%rax
+        jl              .L__vsacg
+
+        mov             16(%rsi),%ecx                   # do the fifth value
+        mov             %ecx,p2_temp+16(%rsp)
+        cmp             $6,%rax
+        jl              .L__vsacg
+
+        mov             20(%rsi),%ecx                   # do the sixth value
+        mov             %ecx,p2_temp+20(%rsp)
+        cmp             $7,%rax
+        jl              .L__vsacg
+
+        mov             24(%rsi),%ecx                   # do the last value
+        mov             %ecx,p2_temp+24(%rsp)
+
+.L__vsacg:
+	mov		$8,%rdi				# parameter for N
+        lea             p2_temp(%rsp),%rsi      # &x parameter
+        lea             p2_temp1(%rsp),%rdx      # &y parameter
+        call		vrsa_log2f@PLT	# call recursively to compute four values
+
+# now copy the results to the destination array
+        mov             save_ya(%rsp),%rdi
+        mov             save_nv(%rsp),%rax      # get number of values
+        mov             p2_temp1(%rsp),%ecx
+        mov             %ecx,(%rdi)                     # we know there's at least one
+        cmp             $2,%rax
+        jl              .L__vsacgf
+
+        mov             p2_temp1+4(%rsp),%ecx
+        mov             %ecx,4(%rdi)                    # do the second value
+        cmp             $3,%rax
+        jl              .L__vsacgf
+
+        mov             p2_temp1+8(%rsp),%ecx
+        mov             %ecx,8(%rdi)                    # do the second value
+        cmp             $4,%rax
+        jl              .L__vsacgf
+
+        mov             p2_temp1+12(%rsp),%ecx
+        mov             %ecx,12(%rdi)                   # do the second value
+        cmp             $5,%rax
+        jl              .L__vsacgf
+
+        mov             p2_temp1+16(%rsp),%ecx
+        mov             %ecx,16(%rdi)                   # do the second value
+        cmp             $6,%rax
+        jl              .L__vsacgf
+
+        mov             p2_temp1+20(%rsp),%ecx
+        mov             %ecx,20(%rdi)                   # do the second value
+        cmp             $7,%rax
+        jl              .L__vsacgf
+
+        mov             p2_temp1+24(%rsp),%ecx
+        mov             %ecx,24(%rdi)                   # do the last value
+
+.L__vsacgf:
+	jmp		.L__final_check
+
+
+.L__vlogf_e:
+	movdqa	p_x(%rsp),%xmm2
+	cmpps	$0,.L__real_ef(%rip),%xmm2
+	movdqa	%xmm2,%xmm3
+	andnps	%xmm0,%xmm3							# keep the non-e values
+	andps	.L__real_one(%rip),%xmm2			# setup the 1 values
+	orps	%xmm3,%xmm2							# merge
+	movdqa	%xmm2,%xmm0							# and replace
+	jmp		.L__f1
+
+.L__vlogf_e2:
+		movdqa	p_x2(%rsp),%xmm2
+		cmpps	$0,.L__real_ef(%rip),%xmm2
+		movdqa	%xmm2,%xmm3
+		andnps	%xmm1,%xmm3							# keep the non-e values
+		andps	.L__real_one(%rip),%xmm2			# setup the 1 values
+		orps	%xmm3,%xmm2							# merge
+		movdqa	%xmm2,%xmm1							# and replace
+		jmp		.L__f12
+
+	.align	16
+.L__near_one:
+# saves 10 cycles
+#      r = x - 1.0;
+	movdqa	%xmm3,p_omask(%rsp)	# save ones mask
+	movaps	p_x(%rsp),%xmm3
+	movaps	.L__real_two(%rip),%xmm2
+	subps	.L__real_one(%rip),%xmm3	   # r
+#      u          = r / (2.0 + r);
+	addps	%xmm3,%xmm2
+	movaps	%xmm3,%xmm1
+	divps	%xmm2,%xmm1		# u
+	movaps	.L__real_ca4(%rip),%xmm4	  #D
+	movaps	.L__real_ca3(%rip),%xmm5	  #C
+#      correction = r * u;
+	movaps	%xmm3,%xmm6
+	mulps	%xmm1,%xmm6		# correction
+	movdqa	%xmm6,p_corr(%rsp)	# save correction
+#      u          = u + u;
+	addps	%xmm1,%xmm1		#u
+	movaps	%xmm1,%xmm2
+	mulps	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulps	%xmm1,%xmm5		# Cu
+	movaps	%xmm1,%xmm6
+	mulps	%xmm2,%xmm6		# u^3
+	mulps	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulps	%xmm6,%xmm4		#Du^3
+
+	addps	.L__real_ca1(%rip),%xmm2	# +A
+	movaps	%xmm6,%xmm1
+	mulps	%xmm1,%xmm1		# u^6
+	addps	%xmm4,%xmm5		#Cu+Du3
+
+	mulps	%xmm6,%xmm2		#u3(A+Bu2)
+	mulps	%xmm5,%xmm1		#u6(Cu+Du3)
+	addps	%xmm1,%xmm2
+	subps	p_corr(%rsp),%xmm2		# -correction
+
+
+#   loge to log2
+	movaps  %xmm3,%xmm5 	#r1=r
+	pand 	.L__mask_lower(%rip),%xmm5
+	subps	%xmm5,%xmm3
+	addps	%xmm3,%xmm2	#r2 = r2 + (r-r1)
+
+	movaps	%xmm5,%xmm3
+	movaps	%xmm2,%xmm1
+
+	mulps 	.L__real_log2e_tail(%rip),%xmm2
+	mulps 	.L__real_log2e_tail(%rip),%xmm3
+	mulps 	.L__real_log2e_lead(%rip),%xmm1
+	mulps 	.L__real_log2e_lead(%rip),%xmm5
+	addps 	%xmm2,%xmm3
+	addps 	%xmm1,%xmm3
+	addps	%xmm5,%xmm3
+
+#      return r + r2;
+#	addps	%xmm2,%xmm3
+
+	movdqa	p_omask(%rsp),%xmm6
+	movdqa	%xmm6,%xmm2
+	andnps	%xmm0,%xmm6					# keep the non-nearone values
+	andps	%xmm3,%xmm2					# setup the nearone values
+	orps	%xmm6,%xmm2					# merge
+	movdqa	%xmm2,%xmm0					# and replace
+
+	jmp		.L__f4
+
+
+	.align	16
+.L__near_one2:
+# saves 10 cycles
+#      r = x - 1.0;
+		movdqa	%xmm9,p_omask(%rsp)	# save ones mask
+		movaps	p_x2(%rsp),%xmm3
+		movaps	.L__real_two(%rip),%xmm2
+		subps	.L__real_one(%rip),%xmm3	   # r
+	#      u          = r / (2.0 + r);
+		addps	%xmm3,%xmm2
+		movaps	%xmm3,%xmm7
+		divps	%xmm2,%xmm7		# u
+		movaps	.L__real_ca4(%rip),%xmm4	  #D
+		movaps	.L__real_ca3(%rip),%xmm5	  #C
+	#      correction = r * u;
+		movaps	%xmm3,%xmm6
+		mulps	%xmm7,%xmm6		# correction
+		movdqa	%xmm6,p_corr(%rsp)	# save correction
+	#      u          = u + u;
+		addps	%xmm7,%xmm7		#u
+		movaps	%xmm7,%xmm2
+		mulps	%xmm2,%xmm2		#v =u^2
+	#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+		mulps	%xmm7,%xmm5		# Cu
+		movaps	%xmm7,%xmm6
+		mulps	%xmm2,%xmm6		# u^3
+		mulps	.L__real_ca2(%rip),%xmm2	#Bu^2
+		mulps	%xmm6,%xmm4		#Du^3
+
+		addps	.L__real_ca1(%rip),%xmm2	# +A
+		movaps	%xmm6,%xmm7
+		mulps	%xmm7,%xmm7		# u^6
+		addps	%xmm4,%xmm5		#Cu+Du3
+
+		mulps	%xmm6,%xmm2		#u3(A+Bu2)
+		mulps	%xmm5,%xmm7		#u6(Cu+Du3)
+		addps	%xmm7,%xmm2
+		subps	p_corr(%rsp),%xmm2		# -correction
+
+# loge to log2
+		movaps  %xmm3,%xmm5 	#r1=r
+		pand 	.L__mask_lower(%rip),%xmm5
+		subps	%xmm5,%xmm3
+		addps	%xmm3,%xmm2 #r2 = r2 + (r-r1)
+
+		movaps	%xmm5,%xmm3
+		movaps	%xmm2,%xmm7
+
+		mulps 	.L__real_log2e_tail(%rip),%xmm2
+		mulps 	.L__real_log2e_tail(%rip),%xmm3
+		mulps 	.L__real_log2e_lead(%rip),%xmm7
+		mulps 	.L__real_log2e_lead(%rip),%xmm5
+		addps 	%xmm2,%xmm3
+		addps 	%xmm7,%xmm3
+		addps	%xmm5,%xmm3
+
+	#      return r + r2;
+#		addps	%xmm2,%xmm3
+
+		movdqa	p_omask(%rsp),%xmm6
+		movdqa	%xmm6,%xmm2
+		andnps	%xmm1,%xmm6					# keep the non-nearone values
+		andps	%xmm3,%xmm2					# setup the nearone values
+		orps	%xmm6,%xmm2					# merge
+		movdqa	%xmm2,%xmm1					# and replace
+
+		jmp		.L__f42
+
+# we have a zero, a negative number, or both.
+# the mask is already in .LNaNs,%xmm1 are also picked up here, along with -inf.
+.L__z_or_neg:
+# deal with negatives first
+	movdqa	%xmm1,%xmm3
+	andps	%xmm0,%xmm3							# keep the non-error values
+	andnps	.L__real_nan(%rip),%xmm1			# setup the nan values
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+# check for +/- 0
+	xorps	%xmm1,%xmm1
+	cmpps	$0,p_x(%rsp),%xmm1	# 0 ?.
+	movmskps	%xmm1,%r9d
+	test		$0x0f,%r9d
+	jz		.L__zn2
+
+	movdqa	%xmm1,%xmm3
+	andnps	%xmm0,%xmm3							# keep the non-error values
+	andps	.L__real_ninf(%rip),%xmm1		# ; C99 specs -inf for +-0
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+
+.L__zn2:
+# check for NaNs
+	movaps	p_x(%rsp),%xmm3
+	andps	.L__real_inf(%rip),%xmm3
+	cmpps	$0,.L__real_inf(%rip),%xmm3		# mask for max exponent
+
+	movdqa	p_x(%rsp),%xmm4
+	pand	.L__real_mant(%rip),%xmm4		# mask for non-zero mantissa
+	pcmpeqd	.L__real_zero(%rip),%xmm4
+	pandn	%xmm3,%xmm4							# mask for NaNs
+	movdqa	%xmm4,%xmm2
+	movdqa	p_x(%rsp),%xmm1			# isolate the NaNs
+	pand	%xmm4,%xmm1
+
+	pand	.L__real_qnanbit(%rip),%xmm4		# now we have a mask that will set QNaN bit
+	por		%xmm1,%xmm4							# turn SNaNs to QNaNs
+
+	movdqa	%xmm2,%xmm1
+	andnps	%xmm0,%xmm2							# keep the non-error values
+	orps	%xmm4,%xmm2							# merge
+	movdqa	%xmm2,%xmm0							# and replace
+	xorps	%xmm4,%xmm4
+
+	jmp		.L__f2
+
+# handle only +inf	 log(+inf) = inf
+.L__log_inf:
+	movdqa	%xmm3,%xmm1
+	andnps	%xmm0,%xmm3							# keep the non-error values
+	andps	p_x(%rsp),%xmm1			# setup the +inf values
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+	jmp		.L__f3
+
+
+.L__z_or_neg2:
+	# deal with negatives first
+		movdqa	%xmm7,%xmm3
+		andps	%xmm1,%xmm3							# keep the non-error values
+		andnps	.L__real_nan(%rip),%xmm7			# setup the nan values
+		orps	%xmm3,%xmm7							# merge
+		movdqa	%xmm7,%xmm1							# and replace
+	# check for +/- 0
+		xorps	%xmm7,%xmm7
+		cmpps	$0,p_x2(%rsp),%xmm7	# 0 ?.
+		movmskps	%xmm7,%r9d
+		test		$0x0f,%r9d
+		jz		.L__zn22
+
+		movdqa	%xmm7,%xmm3
+		andnps	%xmm1,%xmm3							# keep the non-error values
+		andps	.L__real_ninf(%rip),%xmm7		# ; C99 specs -inf for +-0
+		orps	%xmm3,%xmm7							# merge
+		movdqa	%xmm7,%xmm1							# and replace
+
+.L__zn22:
+	# check for NaNs
+		movaps	p_x2(%rsp),%xmm3
+		andps	.L__real_inf(%rip),%xmm3
+		cmpps	$0,.L__real_inf(%rip),%xmm3		# mask for max exponent
+
+		movdqa	p_x2(%rsp),%xmm4
+		pand	.L__real_mant(%rip),%xmm4		# mask for non-zero mantissa
+		pcmpeqd	.L__real_zero(%rip),%xmm4
+		pandn	%xmm3,%xmm4							# mask for NaNs
+		movdqa	%xmm4,%xmm2
+		movdqa	p_x2(%rsp),%xmm7			# isolate the NaNs
+		pand	%xmm4,%xmm7
+
+		pand	.L__real_qnanbit(%rip),%xmm4		# now we have a mask that will set QNaN bit
+		por		%xmm7,%xmm4							# turn SNaNs to QNaNs
+
+		movdqa	%xmm2,%xmm7
+		andnps	%xmm1,%xmm2							# keep the non-error values
+		orps	%xmm4,%xmm2							# merge
+		movdqa	%xmm2,%xmm1							# and replace
+		xorps	%xmm4,%xmm4
+
+		jmp		.L__f22
+
+	# handle only +inf	 log(+inf) = inf
+.L__log_inf2:
+		movdqa	%xmm9,%xmm7
+		andnps	%xmm1,%xmm9							# keep the non-error values
+		andps	p_x2(%rsp),%xmm7			# setup the +inf values
+		orps	%xmm9,%xmm7							# merge
+		movdqa	%xmm7,%xmm1							# and replace
+		jmp		.L__f32
+
+
+        .data
+        .align 64
+
+
+.L__real_zero:				.quad 0x00000000000000000	# 1.0
+					.quad 0x00000000000000000
+.L__real_one:				.quad 0x03f8000003f800000	# 1.0
+					.quad 0x03f8000003f800000
+.L__real_two:				.quad 0x04000000040000000	# 1.0
+					.quad 0x04000000040000000
+.L__real_ninf:				.quad 0x0ff800000ff800000	# -inf
+					.quad 0x0ff800000ff800000
+.L__real_inf:				.quad 0x07f8000007f800000	# +inf
+					.quad 0x07f8000007f800000
+.L__real_nan:				.quad 0x07fc000007fc00000	# NaN
+					.quad 0x07fc000007fc00000
+.L__real_ef:				.quad 0x0402DF854402DF854	# float e
+					.quad 0x0402DF854402DF854
+
+.L__real_sign:				.quad 0x08000000080000000	# sign bit
+					.quad 0x08000000080000000
+.L__real_notsign:			.quad 0x07ffFFFFF7ffFFFFF	# ^sign bit
+					.quad 0x07ffFFFFF7ffFFFFF
+.L__real_qnanbit:			.quad 0x00040000000400000	# quiet nan bit
+					.quad 0x00040000000400000
+.L__real_mant:				.quad 0x0007FFFFF007FFFFF	# mantipsa bits
+					.quad 0x0007FFFFF007FFFFF
+.L__real_3c000000:			.quad 0x03c0000003c000000	# /* 0.0078125 = 1/128 */
+					.quad 0x03c0000003c000000
+.L__mask_127:				.quad 0x00000007f0000007f	#
+					.quad 0x00000007f0000007f
+.L__mask_040:				.quad 0x00000004000000040	#
+					.quad 0x00000004000000040
+.L__mask_001:				.quad 0x00000000100000001	#
+					.quad 0x00000000100000001
+
+
+.L__real_threshold:			.quad 0x03CF5C28F3CF5C28F	# .03
+					.quad 0x03CF5C28F3CF5C28F
+
+.L__real_ca1:				.quad 0x03DAAAAAB3DAAAAAB	# 8.33333333333317923934e-02
+					.quad 0x03DAAAAAB3DAAAAAB
+.L__real_ca2:				.quad 0x03C4CCCCD3C4CCCCD	# 1.25000000037717509602e-02
+					.quad 0x03C4CCCCD3C4CCCCD
+.L__real_ca3:				.quad 0x03B1249183B124918	# 2.23213998791944806202e-03
+					.quad 0x03B1249183B124918
+.L__real_ca4:				.quad 0x039E401A639E401A6	# 4.34887777707614552256e-04
+					.quad 0x039E401A639E401A6
+.L__real_cb1:				.quad 0x03DAAAAAB3DAAAAAB	# 8.33333333333333593622e-02
+					.quad 0x03DAAAAAB3DAAAAAB
+.L__real_cb2:				.quad 0x03C4CCCCD3C4CCCCD	# 1.24999999978138668903e-02
+					.quad 0x03C4CCCCD3C4CCCCD
+.L__real_cb3:				.quad 0x03B124A123B124A12	# 2.23219810758559851206e-03
+					.quad 0x03B124A123B124A12
+.L__real_log2_lead:			.quad 0x03F3170003F317000  # 0.693115234375
+                        		.quad 0x03F3170003F317000
+.L__real_log2_tail:     		.quad 0x03805FDF43805FDF4  # 0.000031946183
+                       			.quad 0x03805FDF43805FDF4
+.L__real_half:				.quad 0x03f0000003f000000	# 1/2
+					.quad 0x03f0000003f000000
+.L__real_log2e_lead:       .quad 0x03FB800003FB80000  #1.4375000000
+                        .quad 0x03FB800003FB80000
+.L__real_log2e_tail:       .quad 0x03BAA3B293BAA3B29  # 0.0051950408889633
+                        .quad 0x03BAA3B293BAA3B29
+
+.L__mask_lower:			.quad 0x0ffff0000ffff0000	#
+						.quad 0x0ffff0000ffff0000
+
+.L__np_ln__table:
+	.quad	0x0000000000000000 		# 0.00000000000000000000e+00
+	.quad	0x3F8FC0A8B0FC03E4		# 1.55041813850402832031e-02
+	.quad	0x3F9F829B0E783300		# 3.07716131210327148438e-02
+	.quad	0x3FA77458F632DCFC		# 4.58095073699951171875e-02
+	.quad	0x3FAF0A30C01162A6		# 6.06245994567871093750e-02
+	.quad	0x3FB341D7961BD1D1		# 7.52233862876892089844e-02
+	.quad	0x3FB6F0D28AE56B4C		# 8.96121263504028320312e-02
+	.quad	0x3FBA926D3A4AD563		# 1.03796780109405517578e-01
+	.quad	0x3FBE27076E2AF2E6		# 1.17783010005950927734e-01
+	.quad	0x3FC0D77E7CD08E59		# 1.31576299667358398438e-01
+	.quad	0x3FC29552F81FF523		# 1.45181953907012939453e-01
+	.quad	0x3FC44D2B6CCB7D1E		# 1.58604979515075683594e-01
+	.quad	0x3FC5FF3070A793D4		# 1.71850204467773437500e-01
+	.quad	0x3FC7AB890210D909		# 1.84922337532043457031e-01
+	.quad	0x3FC9525A9CF456B4		# 1.97825729846954345703e-01
+	.quad	0x3FCAF3C94E80BFF3		# 2.10564732551574707031e-01
+	.quad	0x3FCC8FF7C79A9A22		# 2.23143517971038818359e-01
+	.quad	0x3FCE27076E2AF2E6		# 2.35566020011901855469e-01
+	.quad	0x3FCFB9186D5E3E2B		# 2.47836112976074218750e-01
+	.quad	0x3FD0A324E27390E3		# 2.59957492351531982422e-01
+	.quad	0x3FD1675CABABA60E		# 2.71933674812316894531e-01
+	.quad	0x3FD22941FBCF7966		# 2.83768117427825927734e-01
+	.quad	0x3FD2E8E2BAE11D31		# 2.95464158058166503906e-01
+	.quad	0x3FD3A64C556945EA		# 3.07025015354156494141e-01
+	.quad	0x3FD4618BC21C5EC2		# 3.18453729152679443359e-01
+	.quad	0x3FD51AAD872DF82D		# 3.29753279685974121094e-01
+	.quad	0x3FD5D1BDBF5809CA		# 3.40926527976989746094e-01
+	.quad	0x3FD686C81E9B14AF		# 3.51976394653320312500e-01
+	.quad	0x3FD739D7F6BBD007		# 3.62905442714691162109e-01
+	.quad	0x3FD7EAF83B82AFC3		# 3.73716354370117187500e-01
+	.quad	0x3FD89A3386C1425B		# 3.84411692619323730469e-01
+	.quad	0x3FD947941C2116FB		# 3.94993782043457031250e-01
+	.quad	0x3FD9F323ECBF984C		# 4.05465066432952880859e-01
+	.quad	0x3FDA9CEC9A9A084A		# 4.15827870368957519531e-01
+	.quad	0x3FDB44F77BCC8F63		# 4.26084339618682861328e-01
+	.quad	0x3FDBEB4D9DA71B7C		# 4.36236739158630371094e-01
+	.quad	0x3FDC8FF7C79A9A22		# 4.46287095546722412109e-01
+	.quad	0x3FDD32FE7E00EBD5		# 4.56237375736236572266e-01
+	.quad	0x3FDDD46A04C1C4A1		# 4.66089725494384765625e-01
+	.quad	0x3FDE744261D68788		# 4.75845873355865478516e-01
+	.quad	0x3FDF128F5FAF06ED		# 4.85507786273956298828e-01
+	.quad	0x3FDFAF588F78F31F		# 4.95077252388000488281e-01
+	.quad	0x3FE02552A5A5D0FF		# 5.04556000232696533203e-01
+	.quad	0x3FE0723E5C1CDF40		# 5.13945698738098144531e-01
+	.quad	0x3FE0BE72E4252A83		# 5.23248136043548583984e-01
+	.quad	0x3FE109F39E2D4C97		# 5.32464742660522460938e-01
+	.quad	0x3FE154C3D2F4D5EA		# 5.41597247123718261719e-01
+	.quad	0x3FE19EE6B467C96F		# 5.50647079944610595703e-01
+	.quad	0x3FE1E85F5E7040D0		# 5.59615731239318847656e-01
+	.quad	0x3FE23130D7BEBF43		# 5.68504691123962402344e-01
+	.quad	0x3FE2795E1289B11B		# 5.77315330505371093750e-01
+	.quad	0x3FE2C0E9ED448E8C		# 5.86049020290374755859e-01
+	.quad	0x3FE307D7334F10BE		# 5.94707071781158447266e-01
+	.quad	0x3FE34E289D9CE1D3		# 6.03290796279907226562e-01
+	.quad	0x3FE393E0D3562A1A		# 6.11801505088806152344e-01
+	.quad	0x3FE3D9026A7156FB		# 6.20240390300750732422e-01
+	.quad	0x3FE41D8FE84672AE		# 6.28608644008636474609e-01
+	.quad	0x3FE4618BC21C5EC2		# 6.36907458305358886719e-01
+	.quad	0x3FE4A4F85DB03EBB		# 6.45137906074523925781e-01
+	.quad	0x3FE4E7D811B75BB1		# 6.53301239013671875000e-01
+	.quad	0x3FE52A2D265BC5AB		# 6.61398470401763916016e-01
+	.quad	0x3FE56BF9D5B3F399		# 6.69430613517761230469e-01
+	.quad	0x3FE5AD404C359F2D		# 6.77398800849914550781e-01
+	.quad	0x3FE5EE02A9241675		# 6.85303986072540283203e-01
+	.quad	0x3FE62E42FEFA39EF		# 6.93147122859954833984e-01
+	.quad 0					# for alignment
+
+.L__np_ln_lead_table:
+    .long 0x00000000  # 0.000000000000 0
+    .long 0x3C7E0000  # 0.015502929688 1
+    .long 0x3CFC1000  # 0.030769348145 2
+    .long 0x3D3BA000  # 0.045806884766 3
+    .long 0x3D785000  # 0.060623168945 4
+    .long 0x3D9A0000  # 0.075195312500 5
+    .long 0x3DB78000  # 0.089599609375 6
+    .long 0x3DD49000  # 0.103790283203 7
+    .long 0x3DF13000  # 0.117767333984 8
+    .long 0x3E06B000  # 0.131530761719 9
+    .long 0x3E14A000  # 0.145141601563 10
+    .long 0x3E226000  # 0.158569335938 11
+    .long 0x3E2FF000  # 0.171813964844 12
+    .long 0x3E3D5000  # 0.184875488281 13
+    .long 0x3E4A9000  # 0.197814941406 14
+    .long 0x3E579000  # 0.210510253906 15
+    .long 0x3E647000  # 0.223083496094 16
+    .long 0x3E713000  # 0.235534667969 17
+    .long 0x3E7DC000  # 0.247802734375 18
+    .long 0x3E851000  # 0.259887695313 19
+    .long 0x3E8B3000  # 0.271850585938 20
+    .long 0x3E914000  # 0.283691406250 21
+    .long 0x3E974000  # 0.295410156250 22
+    .long 0x3E9D3000  # 0.307006835938 23
+    .long 0x3EA30000  # 0.318359375000 24
+    .long 0x3EA8D000  # 0.329711914063 25
+    .long 0x3EAE8000  # 0.340820312500 26
+    .long 0x3EB43000  # 0.351928710938 27
+    .long 0x3EB9C000  # 0.362792968750 28
+    .long 0x3EBF5000  # 0.373657226563 29
+    .long 0x3EC4D000  # 0.384399414063 30
+    .long 0x3ECA3000  # 0.394897460938 31
+    .long 0x3ECF9000  # 0.405395507813 32
+    .long 0x3ED4E000  # 0.415771484375 33
+    .long 0x3EDA2000  # 0.426025390625 34
+    .long 0x3EDF5000  # 0.436157226563 35
+    .long 0x3EE47000  # 0.446166992188 36
+    .long 0x3EE99000  # 0.456176757813 37
+    .long 0x3EEEA000  # 0.466064453125 38
+    .long 0x3EF3A000  # 0.475830078125 39
+    .long 0x3EF89000  # 0.485473632813 40
+    .long 0x3EFD7000  # 0.494995117188 41
+    .long 0x3F012000  # 0.504394531250 42
+    .long 0x3F039000  # 0.513916015625 43
+    .long 0x3F05F000  # 0.523193359375 44
+    .long 0x3F084000  # 0.532226562500 45
+    .long 0x3F0AA000  # 0.541503906250 46
+    .long 0x3F0CF000  # 0.550537109375 47
+    .long 0x3F0F4000  # 0.559570312500 48
+    .long 0x3F118000  # 0.568359375000 49
+    .long 0x3F13C000  # 0.577148437500 50
+    .long 0x3F160000  # 0.585937500000 51
+    .long 0x3F183000  # 0.594482421875 52
+    .long 0x3F1A7000  # 0.603271484375 53
+    .long 0x3F1C9000  # 0.611572265625 54
+    .long 0x3F1EC000  # 0.620117187500 55
+    .long 0x3F20E000  # 0.628417968750 56
+    .long 0x3F230000  # 0.636718750000 57
+    .long 0x3F252000  # 0.645019531250 58
+    .long 0x3F273000  # 0.653076171875 59
+    .long 0x3F295000  # 0.661376953125 60
+    .long 0x3F2B5000  # 0.669189453125 61
+    .long 0x3F2D6000  # 0.677246093750 62
+    .long 0x3F2F7000  # 0.685302734375 63
+    .long 0x3F317000  # 0.693115234375 64
+    .long 0					# for alignment
+
+.L__np_ln_tail_table:
+    .long 0x00000000  # 0.000000000000 0
+    .long 0x35A8B0FC  # 0.000001256848 1
+    .long 0x361B0E78  # 0.000002310522 2
+    .long 0x3631EC66  # 0.000002651266 3
+    .long 0x35C30046  # 0.000001452871 4
+    .long 0x37EBCB0E  # 0.000028108738 5
+    .long 0x37528AE5  # 0.000012549314 6
+    .long 0x36DA7496  # 0.000006510479 7
+    .long 0x3783B715  # 0.000015701671 8
+    .long 0x383F3E68  # 0.000045596069 9
+    .long 0x38297C10  # 0.000040408282 10
+    .long 0x3815B666  # 0.000035694240 11
+    .long 0x38183854  # 0.000036292084 12
+    .long 0x38448108  # 0.000046850211 13
+    .long 0x373539E9  # 0.000010801924 14
+    .long 0x3864A740  # 0.000054515200 15
+    .long 0x387BE3CD  # 0.000060055219 16
+    .long 0x3803B715  # 0.000031403342 17
+    .long 0x380C36AF  # 0.000033429529 18
+    .long 0x3892713A  # 0.000069829126 19
+    .long 0x38AE55D6  # 0.000083129547 20
+    .long 0x38A0FDE8  # 0.000076766883 21
+    .long 0x3862BAE1  # 0.000054056643 22
+    .long 0x3798AAD3  # 0.000018199358 23
+    .long 0x38C5E10E  # 0.000094356117 24
+    .long 0x382D872E  # 0.000041372310 25
+    .long 0x38DEDFAC  # 0.000106274470 26
+    .long 0x38481E9B  # 0.000047712219 27
+    .long 0x38EBFB5E  # 0.000112524940 28
+    .long 0x38783B83  # 0.000059183232 29
+    .long 0x374E1B05  # 0.000012284848 30
+    .long 0x38CA0E11  # 0.000096347307 31
+    .long 0x3891F660  # 0.000069600297 32
+    .long 0x386C9A9A  # 0.000056410769 33
+    .long 0x38777BCD  # 0.000059004688 34
+    .long 0x38A6CED4  # 0.000079540216 35
+    .long 0x38FBE3CD  # 0.000120110439 36
+    .long 0x387E7E01  # 0.000060675669 37
+    .long 0x37D40984  # 0.000025276800 38
+    .long 0x3784C3AD  # 0.000015826745 39
+    .long 0x380F5FAF  # 0.000034182969 40
+    .long 0x38AC47BC  # 0.000082149607 41
+    .long 0x392952D3  # 0.000161479504 42
+    .long 0x37F97073  # 0.000029735476 43
+    .long 0x3865C84A  # 0.000054784388 44
+    .long 0x3979CF17  # 0.000238236375 45
+    .long 0x38C3D2F5  # 0.000093376184 46
+    .long 0x38E6B468  # 0.000110008579 47
+    .long 0x383EBCE1  # 0.000045475437 48
+    .long 0x39186BDF  # 0.000145360347 49
+    .long 0x392F0945  # 0.000166927537 50
+    .long 0x38E9ED45  # 0.000111545007 51
+    .long 0x396B99A8  # 0.000224685878 52
+    .long 0x37A27674  # 0.000019367064 53
+    .long 0x397069AB  # 0.000229275480 54
+    .long 0x39013539  # 0.000123222257 55
+    .long 0x3947F423  # 0.000190690669 56
+    .long 0x3945E10E  # 0.000188712234 57
+    .long 0x38F85DB0  # 0.000118430122 58
+    .long 0x396C08DC  # 0.000225100142 59
+    .long 0x37B4996F  # 0.000021529120 60
+    .long 0x397CEADA  # 0.000241200818 61
+    .long 0x3920261B  # 0.000152729845 62
+    .long 0x35AA4906  # 0.000001268724 63
+    .long 0x3805FDF4  # 0.000031946183 64
+    .long 0					# for alignment
+
diff --git a/src/gas/vrsalogf.S b/src/gas/vrsalogf.S
new file mode 100644
index 0000000..1f96523
--- /dev/null
+++ b/src/gas/vrsalogf.S
@@ -0,0 +1,1088 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrsalogf.s
+#
+# An array implementation of the logf libm function.
+#
+# Prototype:
+#
+#    void vrsa_logf(int n, float *x, float *y);
+#
+#   Computes the natural log of x.
+#   Places the results into the supplied y array.
+# Does not perform error handling, but does return C99 values for error
+# inputs.   Denormal results are truncated to 0.
+
+# This array version is basically a unrolling of the by4 scalar single
+# routine.  The second set of operations is performed by the indented
+# instructions interleaved into the first set.
+#
+#
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+       .weak vrsa_logf_
+       .set vrsa_logf_,__vrsa_logf__
+       .weak vrsa_logf__
+       .set vrsa_logf__,__vrsa_logf__
+
+    .text
+    .align 16
+    .p2align 4,,15
+
+#/* a FORTRAN subroutine implementation of array logf
+#**     VRSA_LOGF(N,X,Y)
+# C equivalent*/
+#void vrsa_logf__(int * n, float *x, float *y)
+#{
+#       vrsa_logf(*n,x,y);
+#}
+.globl __vrsa_logf__
+    .type   __vrsa_logf__,@function
+__vrsa_logf__:
+    mov         (%rdi),%edi
+
+    .align 16
+    .p2align 4,,15
+
+
+# define local variable storage offsets
+.equ	p_x,0			# save x
+.equ	p_idx,0x010		# xmmword index
+.equ	p_z1,0x020		# xmmword index
+.equ	p_q,0x030		# xmmword index
+.equ	p_corr,0x040		# xmmword index
+.equ	p_omask,0x050		# xmmword index
+
+
+.equ	p_x2,0x0100		# save x
+.equ	p_idx2,0x0110		# xmmword index
+.equ	p_z12,0x0120		# xmmword index
+.equ	p_q2,0x0130		# xmmword index
+
+.equ	save_xa,0x0140		#qword
+.equ	save_ya,0x0148		#qword
+.equ	save_nv,0x0150		#qword
+.equ	p_iter,0x0158		# qword	storage for number of loop iterations
+
+.equ	save_rbx,0x0160		#
+.equ	save_rdi,0x0168		#qword
+.equ	save_rsi,0x0170		#qword
+
+.equ	p2_temp,0x0180		#qword
+.equ	p2_temp1,0x01a0		#qword
+
+.equ	stack_size,0x01c8
+
+
+
+
+# parameters are passed in by gcc as:
+# rdi - int n
+# rsi - double *x
+# rdx - double *y
+
+.globl vrsa_logf
+    .type   vrsa_logf,@function
+vrsa_logf:
+	sub		$stack_size,%rsp
+	mov		%rbx,save_rbx(%rsp)	# save rdi
+
+# save the arguments
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+	mov		%rdx,save_ya(%rsp)	# save y_array pointer
+#ifdef INTEGER64
+        mov             %rdi,%rax
+#else
+        mov             %edi,%eax
+        mov             %rax,%rdi
+#endif
+	mov		%rdi,save_nv(%rsp)	# save number of values
+# see if too few values to call the main loop
+	shr		$3,%rax						# get number of iterations
+	jz		.L__vsa_cleanup				# jump if only single calls
+# prepare the iteration counts
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	shl		$3,%rax
+	sub		%rax,%rdi						# compute number of extra single calls
+	mov		%rdi,save_nv(%rsp)	# save number of left over values
+
+# In this second version, process the array 8 values at a time.
+
+.L__vsa_top:
+# build the input _m128
+	mov		save_xa(%rsp),%rsi	# get x_array pointer
+	movups	(%rsi),%xmm0
+		movups	16(%rsi),%xmm12
+#	movhps	.LQWORD,%xmm0 PTR [rsi+8]
+	prefetch	64(%rsi)
+	add		$32,%rsi
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+
+
+# check e as a special case
+	movdqa	%xmm0,p_x(%rsp)	# save x
+		movdqa	%xmm12,p_x2(%rsp)	# save x
+	movdqa	%xmm0,%xmm2
+	cmpps	$0,.L__real_ef(%rip),%xmm2
+	movmskps	%xmm2,%r9d
+
+		movdqa	%xmm12,%xmm9
+		movaps	%xmm12,%xmm7
+
+#
+# compute the index into the log tables
+#
+	movdqa	%xmm0,%xmm3
+	movaps	%xmm0,%xmm1
+	psrld	$23,%xmm3
+
+	#
+	# compute the index into the log tables
+	#
+		psrld	$23,%xmm9
+		subps	.L__real_one(%rip),%xmm7
+		psubd	.L__mask_127(%rip),%xmm9
+	subps	.L__real_one(%rip),%xmm1
+	psubd	.L__mask_127(%rip),%xmm3
+		cvtdq2ps	%xmm9,%xmm13			# xexp
+
+		movdqa	%xmm12,%xmm9
+		pand	.L__real_mant(%rip),%xmm9
+		xor		%r8,%r8
+		movdqa	%xmm9,%xmm8
+		movaps	.L__real_half(%rip),%xmm11							# .5
+	cvtdq2ps	%xmm3,%xmm6			# xexp
+
+	movdqa	%xmm0,%xmm3
+	pand	.L__real_mant(%rip),%xmm3
+	xor		%r8,%r8
+	movdqa	%xmm3,%xmm2
+	movaps	.L__real_half(%rip),%xmm5							# .5
+
+#/* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+	psrld	$16,%xmm3
+	lea		.L__np_ln_lead_table(%rip),%rdx
+	movdqa	%xmm3,%xmm4
+		psrld	$16,%xmm9
+		movdqa	%xmm9,%xmm10
+		psrld	$1,%xmm9
+	psrld	$1,%xmm3
+	paddd	.L__mask_040(%rip),%xmm3
+	pand	.L__mask_001(%rip),%xmm4
+	paddd	%xmm4,%xmm3
+	cvtdq2ps	%xmm3,%xmm1
+	#/* Now  x = 2**xexp  * f,  1/2 <= f < 1. */
+		paddd	.L__mask_040(%rip),%xmm9
+		pand	.L__mask_001(%rip),%xmm10
+		paddd	%xmm10,%xmm9
+		cvtdq2ps	%xmm9,%xmm7
+	packssdw	%xmm3,%xmm3
+	movq	%xmm3,p_idx(%rsp)
+		packssdw	%xmm9,%xmm9
+		movq	%xmm9,p_idx2(%rsp)
+
+
+# reduce and get u
+	movdqa	%xmm0,%xmm3
+	orps		.L__real_half(%rip),%xmm2
+
+
+	mulps	.L__real_3c000000(%rip),%xmm1				# f1 = index/128
+	# reduce and get u
+
+
+	subps	%xmm1,%xmm2											# f2 = f - f1
+	mulps	%xmm2,%xmm5
+	addps	%xmm5,%xmm1
+
+	divps	%xmm1,%xmm2				# u
+
+		movdqa	%xmm12,%xmm9
+		orps		.L__real_half(%rip),%xmm8
+
+
+		mulps	.L__real_3c000000(%rip),%xmm7				# f1 = index/128
+		subps	%xmm7,%xmm8											# f2 = f - f1
+		mulps	%xmm8,%xmm11
+		addps	%xmm11,%xmm7
+
+
+        mov             p_idx(%rsp),%rcx                        # get the indexes
+        mov             %cx,%r8w
+        ror             $16,%rcx
+        mov             -256(%rdx,%r8,4),%eax           # get the f1 value
+
+        mov             %cx,%r8w
+        ror             $16,%rcx
+        mov             -256(%rdx,%r8,4),%ebx           # get the f1 value
+        shl             $32,%rbx
+        or              %rbx,%rax
+        mov              %rax,p_z1(%rsp)                        # save the f1 values
+
+
+        mov             %cx,%r8w
+        ror             $16,%rcx
+        mov             -256(%rdx,%r8,4),%eax           # get the f1 value
+
+        mov             %cx,%r8w
+        ror             $16,%rcx
+        or              -256(%rdx,%r8,4),%ebx           # get the f1 value
+        shl             $32,%rbx
+        or              %rbx,%rax
+        mov              %rax,p_z1+8(%rsp)                      # save the f1 value
+
+		divps	%xmm7,%xmm8				# u
+		lea		.L__np_ln_lead_table(%rip),%rdx
+                mov             p_idx2(%rsp),%rcx                       # get the indexes
+                mov             %cx,%r8w
+                ror             $16,%rcx
+                mov             -256(%rdx,%r8,4),%eax           # get the f1 value
+
+                mov             %cx,%r8w
+                ror             $16,%rcx
+                mov             -256(%rdx,%r8,4),%ebx           # get the f1 value
+                shl             $32,%rbx
+                or              %rbx,%rax
+                mov              %rax,p_z12(%rsp)                       # save the f1 values
+
+
+                mov             %cx,%r8w
+                ror             $16,%rcx
+                mov             -256(%rdx,%r8,4),%eax           # get the f1 value
+
+                mov             %cx,%r8w
+                ror             $16,%rcx
+                or              -256(%rdx,%r8,4),%ebx           # get the f1 value
+                shl             $32,%rbx
+                or              %rbx,%rax
+                mov              %rax,p_z12+8(%rsp)                     # save the f1 value
+
+# solve for ln(1+u)
+	movaps	%xmm2,%xmm1				# u
+	mulps	%xmm2,%xmm2				# u^2
+	movaps	%xmm2,%xmm5
+	movaps	.L__real_cb3(%rip),%xmm3
+	mulps	%xmm2,%xmm3				#Cu2
+	mulps	%xmm1,%xmm5				# u^3
+	addps	.L__real_cb2(%rip),%xmm3 #B+Cu2
+	movaps	%xmm2,%xmm4
+	mulps	%xmm5,%xmm4				# u^5
+	movaps	.L__real_log2_lead(%rip),%xmm2
+
+	mulps	.L__real_cb1(%rip),%xmm5 #Au3
+	addps	%xmm5,%xmm1				# u+Au3
+	mulps	%xmm3,%xmm4				# u5(B+Cu2)
+
+	lea		.L__np_ln_tail_table(%rip),%rdx
+	addps	%xmm4,%xmm1				# poly
+
+# recombine
+	mov		p_idx(%rsp),%rcx 			# get the indexes
+        mov             %cx,%r8w
+        shr             $16,%rcx
+        mov             -256(%rdx,%r8,4),%eax           # get the f2 value
+
+        mov             %cx,%r8w
+        shr             $16,%rcx
+        or              -256(%rdx,%r8,4),%ebx           # get the f2 value
+        shl             $32,%rbx
+        or              %rbx,%rax
+        mov              %rax,p_q(%rsp)                         # save the f2 value
+
+
+        mov             %cx,%r8w
+        shr             $16,%rcx
+        mov             -256(%rdx,%r8,4),%eax           # get the f2 value
+
+        mov             %cx,%r8w
+        mov             -256(%rdx,%r8,4),%ebx           # get the f2 value
+        shl             $32,%rbx
+        or              %rbx,%rax
+        mov              %rax,p_q+8(%rsp)                       # save the f2 value
+
+	addps	p_q(%rsp),%xmm1 #z2	+=q
+
+	movaps	p_z1(%rsp),%xmm0			# z1  values
+
+	mulps	%xmm6,%xmm2
+	addps	%xmm2,%xmm0				#r1
+	mulps	.L__real_log2_tail(%rip),%xmm6
+	addps	%xmm6,%xmm1				#r2
+	addps	%xmm1,%xmm0
+
+
+
+# check for e
+	test		$0x0f,%r9d
+	jnz			.L__vlogf_e
+.L__f1:
+
+# check for negative numbers or zero
+	xorps	%xmm1,%xmm1
+	cmpps	$1,p_x(%rsp),%xmm1	# 0 greater than =?. catches NaNs also.
+	movmskps	%xmm1,%r9d
+	cmp		$0x0f,%r9d
+	jnz		.L__z_or_neg
+
+.L__f2:
+##  if +inf
+	movaps	p_x(%rsp),%xmm3
+	cmpps	$0,.L__real_inf(%rip),%xmm3
+	movmskps	%xmm3,%r9d
+	test		$0x0f,%r9d
+	jnz		.L__log_inf
+.L__f3:
+
+	movaps	p_x(%rsp),%xmm3
+	subps	.L__real_one(%rip),%xmm3
+	andps	.L__real_notsign(%rip),%xmm3
+	cmpps	$2,.L__real_threshold(%rip),%xmm3
+	movmskps	%xmm3,%r9d
+	test	$0x0f,%r9d
+	jnz		.L__near_one
+.L__f4:
+
+# store the result _m128d
+	mov		save_ya(%rsp),%rdi	# get y_array pointer
+	movups	%xmm0,(%rdi)
+
+# finish the second set of calculations
+
+	# solve for ln(1+u)
+		movaps	%xmm8,%xmm7				# u
+		mulps	%xmm8,%xmm8				# u^2
+		movaps	%xmm8,%xmm11
+
+		movaps	.L__real_cb3(%rip),%xmm9
+		mulps	%xmm8,%xmm9				#Cu2
+		mulps	%xmm7,%xmm11				# u^3
+		addps	.L__real_cb2(%rip),%xmm9 #B+Cu2
+		movaps	%xmm8,%xmm10
+		mulps	%xmm11,%xmm10				# u^5
+		movaps	.L__real_log2_lead(%rip),%xmm8
+
+		mulps	.L__real_cb1(%rip),%xmm11 #Au3
+		addps	%xmm11,%xmm7				# u+Au3
+		mulps	%xmm9,%xmm10				# u5(B+Cu2)
+		addps	%xmm10,%xmm7				# poly
+
+
+	# recombine
+		lea		.L__np_ln_tail_table(%rip),%rdx
+		mov		p_idx2(%rsp),%rcx 			# get the indexes
+		mov             %cx,%r8w
+                shr             $16,%rcx
+                mov             -256(%rdx,%r8,4),%eax           # get the f2 value
+
+                mov             %cx,%r8w
+                shr             $16,%rcx
+                or              -256(%rdx,%r8,4),%ebx           # get the f2 value
+                shl             $32,%rbx
+                or              %rbx,%rax
+                mov              %rax,p_q2(%rsp)                        # save the f2 value
+
+
+                mov             %cx,%r8w
+                shr             $16,%rcx
+                mov             -256(%rdx,%r8,4),%eax           # get the f2 value
+
+                mov             %cx,%r8w
+                mov             -256(%rdx,%r8,4),%ebx           # get the f2 value
+                shl             $32,%rbx
+                or              %rbx,%rax
+                mov              %rax,p_q2+8(%rsp)                      # save the f2 value
+
+                addps   p_q2(%rsp),%xmm7 #z2    +=q
+		movaps	p_z12(%rsp),%xmm1			# z1  values
+
+		mulps	%xmm13,%xmm8
+		addps	%xmm8,%xmm1				#r1
+		mulps	.L__real_log2_tail(%rip),%xmm13
+		addps	%xmm13,%xmm7				#r2
+		addps	%xmm7,%xmm1
+
+	# check e as a special case
+		movaps	p_x2(%rsp),%xmm10
+		cmpps	$0,.L__real_ef(%rip),%xmm10
+		movmskps	%xmm10,%r9d
+	# check for e
+		test		$0x0f,%r9d
+		jnz			.L__vlogf_e2
+.L__f12:
+
+	# check for negative numbers or zero
+		xorps	%xmm7,%xmm7
+		cmpps	$1,p_x2(%rsp),%xmm7	# 0 greater than =?. catches NaNs also.
+		movmskps	%xmm7,%r9d
+		cmp		$0x0f,%r9d
+		jnz		.L__z_or_neg2
+
+.L__f22:
+	##  if +inf
+		movaps	p_x2(%rsp),%xmm9
+		cmpps	$0,.L__real_inf(%rip),%xmm9
+		movmskps	%xmm9,%r9d
+		test		$0x0f,%r9d
+		jnz		.L__log_inf2
+.L__f32:
+
+		movaps	p_x2(%rsp),%xmm9
+		subps	.L__real_one(%rip),%xmm9
+		andps	.L__real_notsign(%rip),%xmm9
+		cmpps	$2,.L__real_threshold(%rip),%xmm9
+		movmskps	%xmm9,%r9d
+		test	$0x0f,%r9d
+		jnz		.L__near_one2
+.L__f42:
+
+
+	prefetch	64(%rsi)
+	add		$32,%rdi
+	mov		%rdi,save_ya(%rsp)	# save y_array pointer
+
+# store the result _m128d
+                movups  %xmm1,-16(%rdi)
+
+	mov		p_iter(%rsp),%rax	# get number of iterations
+	sub		$1,%rax
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	jnz		.L__vsa_top
+
+
+# see if we need to do any extras
+	mov		save_nv(%rsp),%rax	# get number of values
+	test	%rax,%rax
+	jnz		.L__vsa_cleanup
+
+
+#
+.L__final_check:
+	mov		save_rbx(%rsp),%rbx		# restore rbx
+	add		$stack_size,%rsp
+	ret
+
+
+
+	.align	16
+# we jump here when we have an odd number of log calls to make at the
+# end
+.L__vsa_cleanup:
+        mov             save_nv(%rsp),%rax      # get number of values
+        test            %rax,%rax               # are there any values
+        jz              .L__final_check         # exit if not
+
+	mov		save_xa(%rsp),%rsi
+	mov		save_ya(%rsp),%rdi
+
+# fill in a m128 with zeroes and the extra values and then make a recursive call.
+	xorps		%xmm0,%xmm0
+        movaps   %xmm0,p2_temp(%rsp)
+        movaps   %xmm0,p2_temp+16(%rsp)
+
+        mov             (%rsi),%ecx                     # we know there's at least one
+        mov             %ecx,p2_temp(%rsp)
+        cmp             $2,%rax
+        jl              .L__vsacg
+
+        mov             4(%rsi),%ecx                    # do the second value
+        mov             %ecx,p2_temp+4(%rsp)
+        cmp             $3,%rax
+        jl              .L__vsacg
+
+        mov             8(%rsi),%ecx                    # do the third value
+        mov             %ecx,p2_temp+8(%rsp)
+        cmp             $4,%rax
+        jl              .L__vsacg
+
+        mov             12(%rsi),%ecx                   # do the fourth value
+        mov             %ecx,p2_temp+12(%rsp)
+        cmp             $5,%rax
+        jl              .L__vsacg
+
+        mov             16(%rsi),%ecx                   # do the fifth value
+        mov             %ecx,p2_temp+16(%rsp)
+        cmp             $6,%rax
+        jl              .L__vsacg
+
+        mov             20(%rsi),%ecx                   # do the sixth value
+        mov             %ecx,p2_temp+20(%rsp)
+        cmp             $7,%rax
+        jl              .L__vsacg
+
+        mov             24(%rsi),%ecx                   # do the last value
+        mov             %ecx,p2_temp+24(%rsp)
+
+.L__vsacg:
+	mov		$8,%rdi				# parameter for N
+        lea             p2_temp(%rsp),%rsi      # &x parameter
+        lea             p2_temp1(%rsp),%rdx      # &y parameter
+        call		vrsa_logf@PLT	# call recursively to compute four values
+
+# now copy the results to the destination array
+        mov             save_ya(%rsp),%rdi
+        mov             save_nv(%rsp),%rax      # get number of values
+        mov             p2_temp1(%rsp),%ecx
+        mov             %ecx,(%rdi)                     # we know there's at least one
+        cmp             $2,%rax
+        jl              .L__vsacgf
+
+        mov             p2_temp1+4(%rsp),%ecx
+        mov             %ecx,4(%rdi)                    # do the second value
+        cmp             $3,%rax
+        jl              .L__vsacgf
+
+        mov             p2_temp1+8(%rsp),%ecx
+        mov             %ecx,8(%rdi)                    # do the second value
+        cmp             $4,%rax
+        jl              .L__vsacgf
+
+        mov             p2_temp1+12(%rsp),%ecx
+        mov             %ecx,12(%rdi)                   # do the second value
+        cmp             $5,%rax
+        jl              .L__vsacgf
+
+        mov             p2_temp1+16(%rsp),%ecx
+        mov             %ecx,16(%rdi)                   # do the second value
+        cmp             $6,%rax
+        jl              .L__vsacgf
+
+        mov             p2_temp1+20(%rsp),%ecx
+        mov             %ecx,20(%rdi)                   # do the second value
+        cmp             $7,%rax
+        jl              .L__vsacgf
+
+        mov             p2_temp1+24(%rsp),%ecx
+        mov             %ecx,24(%rdi)                   # do the last value
+
+.L__vsacgf:
+	jmp		.L__final_check
+
+
+.L__vlogf_e:
+	movdqa	p_x(%rsp),%xmm2
+	cmpps	$0,.L__real_ef(%rip),%xmm2
+	movdqa	%xmm2,%xmm3
+	andnps	%xmm0,%xmm3							# keep the non-e values
+	andps	.L__real_one(%rip),%xmm2			# setup the 1 values
+	orps	%xmm3,%xmm2							# merge
+	movdqa	%xmm2,%xmm0							# and replace
+	jmp		.L__f1
+
+.L__vlogf_e2:
+		movdqa	p_x2(%rsp),%xmm2
+		cmpps	$0,.L__real_ef(%rip),%xmm2
+		movdqa	%xmm2,%xmm3
+		andnps	%xmm1,%xmm3							# keep the non-e values
+		andps	.L__real_one(%rip),%xmm2			# setup the 1 values
+		orps	%xmm3,%xmm2							# merge
+		movdqa	%xmm2,%xmm1							# and replace
+		jmp		.L__f12
+
+	.align	16
+.L__near_one:
+# saves 10 cycles
+#      r = x - 1.0;
+	movdqa	%xmm3,p_omask(%rsp)	# save ones mask
+	movaps	p_x(%rsp),%xmm3
+	movaps	.L__real_two(%rip),%xmm2
+	subps	.L__real_one(%rip),%xmm3	   # r
+#      u          = r / (2.0 + r);
+	addps	%xmm3,%xmm2
+	movaps	%xmm3,%xmm1
+	divps	%xmm2,%xmm1		# u
+	movaps	.L__real_ca4(%rip),%xmm4	  #D
+	movaps	.L__real_ca3(%rip),%xmm5	  #C
+#      correction = r * u;
+	movaps	%xmm3,%xmm6
+	mulps	%xmm1,%xmm6		# correction
+	movdqa	%xmm6,p_corr(%rsp)	# save correction
+#      u          = u + u;
+	addps	%xmm1,%xmm1		#u
+	movaps	%xmm1,%xmm2
+	mulps	%xmm2,%xmm2		#v =u^2
+#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+	mulps	%xmm1,%xmm5		# Cu
+	movaps	%xmm1,%xmm6
+	mulps	%xmm2,%xmm6		# u^3
+	mulps	.L__real_ca2(%rip),%xmm2	#Bu^2
+	mulps	%xmm6,%xmm4		#Du^3
+
+	addps	.L__real_ca1(%rip),%xmm2	# +A
+	movaps	%xmm6,%xmm1
+	mulps	%xmm1,%xmm1		# u^6
+	addps	%xmm4,%xmm5		#Cu+Du3
+
+	mulps	%xmm6,%xmm2		#u3(A+Bu2)
+	mulps	%xmm5,%xmm1		#u6(Cu+Du3)
+	addps	%xmm1,%xmm2
+	subps	p_corr(%rsp),%xmm2		# -correction
+
+#      return r + r2;
+	addps	%xmm2,%xmm3
+
+	movdqa	p_omask(%rsp),%xmm6
+	movdqa	%xmm6,%xmm2
+	andnps	%xmm0,%xmm6					# keep the non-nearone values
+	andps	%xmm3,%xmm2					# setup the nearone values
+	orps	%xmm6,%xmm2					# merge
+	movdqa	%xmm2,%xmm0					# and replace
+
+	jmp		.L__f4
+
+
+	.align	16
+.L__near_one2:
+# saves 10 cycles
+#      r = x - 1.0;
+		movdqa	%xmm9,p_omask(%rsp)	# save ones mask
+		movaps	p_x2(%rsp),%xmm3
+		movaps	.L__real_two(%rip),%xmm2
+		subps	.L__real_one(%rip),%xmm3	   # r
+	#      u          = r / (2.0 + r);
+		addps	%xmm3,%xmm2
+		movaps	%xmm3,%xmm7
+		divps	%xmm2,%xmm7		# u
+		movaps	.L__real_ca4(%rip),%xmm4	  #D
+		movaps	.L__real_ca3(%rip),%xmm5	  #C
+	#      correction = r * u;
+		movaps	%xmm3,%xmm6
+		mulps	%xmm7,%xmm6		# correction
+		movdqa	%xmm6,p_corr(%rsp)	# save correction
+	#      u          = u + u;
+		addps	%xmm7,%xmm7		#u
+		movaps	%xmm7,%xmm2
+		mulps	%xmm2,%xmm2		#v =u^2
+	#      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+		mulps	%xmm7,%xmm5		# Cu
+		movaps	%xmm7,%xmm6
+		mulps	%xmm2,%xmm6		# u^3
+		mulps	.L__real_ca2(%rip),%xmm2	#Bu^2
+		mulps	%xmm6,%xmm4		#Du^3
+
+		addps	.L__real_ca1(%rip),%xmm2	# +A
+		movaps	%xmm6,%xmm7
+		mulps	%xmm7,%xmm7		# u^6
+		addps	%xmm4,%xmm5		#Cu+Du3
+
+		mulps	%xmm6,%xmm2		#u3(A+Bu2)
+		mulps	%xmm5,%xmm7		#u6(Cu+Du3)
+		addps	%xmm7,%xmm2
+		subps	p_corr(%rsp),%xmm2		# -correction
+
+	#      return r + r2;
+		addps	%xmm2,%xmm3
+
+		movdqa	p_omask(%rsp),%xmm6
+		movdqa	%xmm6,%xmm2
+		andnps	%xmm1,%xmm6					# keep the non-nearone values
+		andps	%xmm3,%xmm2					# setup the nearone values
+		orps	%xmm6,%xmm2					# merge
+		movdqa	%xmm2,%xmm1					# and replace
+
+		jmp		.L__f42
+
+# we have a zero, a negative number, or both.
+# the mask is already in .LNaNs,%xmm1 are also picked up here, along with -inf.
+.L__z_or_neg:
+# deal with negatives first
+	movdqa	%xmm1,%xmm3
+	andps	%xmm0,%xmm3							# keep the non-error values
+	andnps	.L__real_nan(%rip),%xmm1			# setup the nan values
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+# check for +/- 0
+	xorps	%xmm1,%xmm1
+	cmpps	$0,p_x(%rsp),%xmm1	# 0 ?.
+	movmskps	%xmm1,%r9d
+	test		$0x0f,%r9d
+	jz		.L__zn2
+
+	movdqa	%xmm1,%xmm3
+	andnps	%xmm0,%xmm3							# keep the non-error values
+	andps	.L__real_ninf(%rip),%xmm1		# ; C99 specs -inf for +-0
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+
+.L__zn2:
+# check for NaNs
+	movaps	p_x(%rsp),%xmm3
+	andps	.L__real_inf(%rip),%xmm3
+	cmpps	$0,.L__real_inf(%rip),%xmm3		# mask for max exponent
+
+	movdqa	p_x(%rsp),%xmm4
+	pand	.L__real_mant(%rip),%xmm4		# mask for non-zero mantissa
+	pcmpeqd	.L__real_zero(%rip),%xmm4
+	pandn	%xmm3,%xmm4							# mask for NaNs
+	movdqa	%xmm4,%xmm2
+	movdqa	p_x(%rsp),%xmm1			# isolate the NaNs
+	pand	%xmm4,%xmm1
+
+	pand	.L__real_qnanbit(%rip),%xmm4		# now we have a mask that will set QNaN bit
+	por		%xmm1,%xmm4							# turn SNaNs to QNaNs
+
+	movdqa	%xmm2,%xmm1
+	andnps	%xmm0,%xmm2							# keep the non-error values
+	orps	%xmm4,%xmm2							# merge
+	movdqa	%xmm2,%xmm0							# and replace
+	xorps	%xmm4,%xmm4
+
+	jmp		.L__f2
+
+# handle only +inf	 log(+inf) = inf
+.L__log_inf:
+	movdqa	%xmm3,%xmm1
+	andnps	%xmm0,%xmm3							# keep the non-error values
+	andps	p_x(%rsp),%xmm1			# setup the +inf values
+	orps	%xmm3,%xmm1							# merge
+	movdqa	%xmm1,%xmm0							# and replace
+	jmp		.L__f3
+
+
+.L__z_or_neg2:
+	# deal with negatives first
+		movdqa	%xmm7,%xmm3
+		andps	%xmm1,%xmm3							# keep the non-error values
+		andnps	.L__real_nan(%rip),%xmm7			# setup the nan values
+		orps	%xmm3,%xmm7							# merge
+		movdqa	%xmm7,%xmm1							# and replace
+	# check for +/- 0
+		xorps	%xmm7,%xmm7
+		cmpps	$0,p_x2(%rsp),%xmm7	# 0 ?.
+		movmskps	%xmm7,%r9d
+		test		$0x0f,%r9d
+		jz		.L__zn22
+
+		movdqa	%xmm7,%xmm3
+		andnps	%xmm1,%xmm3							# keep the non-error values
+		andps	.L__real_ninf(%rip),%xmm7		# ; C99 specs -inf for +-0
+		orps	%xmm3,%xmm7							# merge
+		movdqa	%xmm7,%xmm1							# and replace
+
+.L__zn22:
+	# check for NaNs
+		movaps	p_x2(%rsp),%xmm3
+		andps	.L__real_inf(%rip),%xmm3
+		cmpps	$0,.L__real_inf(%rip),%xmm3		# mask for max exponent
+
+		movdqa	p_x2(%rsp),%xmm4
+		pand	.L__real_mant(%rip),%xmm4		# mask for non-zero mantissa
+		pcmpeqd	.L__real_zero(%rip),%xmm4
+		pandn	%xmm3,%xmm4							# mask for NaNs
+		movdqa	%xmm4,%xmm2
+		movdqa	p_x2(%rsp),%xmm7			# isolate the NaNs
+		pand	%xmm4,%xmm7
+
+		pand	.L__real_qnanbit(%rip),%xmm4		# now we have a mask that will set QNaN bit
+		por		%xmm7,%xmm4							# turn SNaNs to QNaNs
+
+		movdqa	%xmm2,%xmm7
+		andnps	%xmm1,%xmm2							# keep the non-error values
+		orps	%xmm4,%xmm2							# merge
+		movdqa	%xmm2,%xmm1							# and replace
+		xorps	%xmm4,%xmm4
+
+		jmp		.L__f22
+
+	# handle only +inf	 log(+inf) = inf
+.L__log_inf2:
+		movdqa	%xmm9,%xmm7
+		andnps	%xmm1,%xmm9							# keep the non-error values
+		andps	p_x2(%rsp),%xmm7			# setup the +inf values
+		orps	%xmm9,%xmm7							# merge
+		movdqa	%xmm7,%xmm1							# and replace
+		jmp		.L__f32
+
+
+        .data
+        .align 64
+
+
+.L__real_zero:				.quad 0x00000000000000000	# 1.0
+					.quad 0x00000000000000000
+.L__real_one:				.quad 0x03f8000003f800000	# 1.0
+					.quad 0x03f8000003f800000
+.L__real_two:				.quad 0x04000000040000000	# 1.0
+					.quad 0x04000000040000000
+.L__real_ninf:				.quad 0x0ff800000ff800000	# -inf
+					.quad 0x0ff800000ff800000
+.L__real_inf:				.quad 0x07f8000007f800000	# +inf
+					.quad 0x07f8000007f800000
+.L__real_nan:				.quad 0x07fc000007fc00000	# NaN
+					.quad 0x07fc000007fc00000
+.L__real_ef:				.quad 0x0402DF854402DF854	# float e
+					.quad 0x0402DF854402DF854
+
+.L__real_sign:				.quad 0x08000000080000000	# sign bit
+					.quad 0x08000000080000000
+.L__real_notsign:			.quad 0x07ffFFFFF7ffFFFFF	# ^sign bit
+					.quad 0x07ffFFFFF7ffFFFFF
+.L__real_qnanbit:			.quad 0x00040000000400000	# quiet nan bit
+					.quad 0x00040000000400000
+.L__real_mant:				.quad 0x0007FFFFF007FFFFF	# mantipsa bits
+					.quad 0x0007FFFFF007FFFFF
+.L__real_3c000000:			.quad 0x03c0000003c000000	# /* 0.0078125 = 1/128 */
+					.quad 0x03c0000003c000000
+.L__mask_127:				.quad 0x00000007f0000007f	#
+					.quad 0x00000007f0000007f
+.L__mask_040:				.quad 0x00000004000000040	#
+					.quad 0x00000004000000040
+.L__mask_001:				.quad 0x00000000100000001	#
+					.quad 0x00000000100000001
+
+
+.L__real_threshold:			.quad 0x03CF5C28F3CF5C28F	# .03
+					.quad 0x03CF5C28F3CF5C28F
+
+.L__real_ca1:				.quad 0x03DAAAAAB3DAAAAAB	# 8.33333333333317923934e-02
+					.quad 0x03DAAAAAB3DAAAAAB
+.L__real_ca2:				.quad 0x03C4CCCCD3C4CCCCD	# 1.25000000037717509602e-02
+					.quad 0x03C4CCCCD3C4CCCCD
+.L__real_ca3:				.quad 0x03B1249183B124918	# 2.23213998791944806202e-03
+					.quad 0x03B1249183B124918
+.L__real_ca4:				.quad 0x039E401A639E401A6	# 4.34887777707614552256e-04
+					.quad 0x039E401A639E401A6
+.L__real_cb1:				.quad 0x03DAAAAAB3DAAAAAB	# 8.33333333333333593622e-02
+					.quad 0x03DAAAAAB3DAAAAAB
+.L__real_cb2:				.quad 0x03C4CCCCD3C4CCCCD	# 1.24999999978138668903e-02
+					.quad 0x03C4CCCCD3C4CCCCD
+.L__real_cb3:				.quad 0x03B124A123B124A12	# 2.23219810758559851206e-03
+					.quad 0x03B124A123B124A12
+.L__real_log2_lead:			.quad 0x03F3170003F317000  # 0.693115234375
+                        		.quad 0x03F3170003F317000
+.L__real_log2_tail:     		.quad 0x03805FDF43805FDF4  # 0.000031946183
+                       			.quad 0x03805FDF43805FDF4
+.L__real_half:				.quad 0x03f0000003f000000	# 1/2
+					.quad 0x03f0000003f000000
+
+
+.L__np_ln__table:
+	.quad	0x0000000000000000 		# 0.00000000000000000000e+00
+	.quad	0x3F8FC0A8B0FC03E4		# 1.55041813850402832031e-02
+	.quad	0x3F9F829B0E783300		# 3.07716131210327148438e-02
+	.quad	0x3FA77458F632DCFC		# 4.58095073699951171875e-02
+	.quad	0x3FAF0A30C01162A6		# 6.06245994567871093750e-02
+	.quad	0x3FB341D7961BD1D1		# 7.52233862876892089844e-02
+	.quad	0x3FB6F0D28AE56B4C		# 8.96121263504028320312e-02
+	.quad	0x3FBA926D3A4AD563		# 1.03796780109405517578e-01
+	.quad	0x3FBE27076E2AF2E6		# 1.17783010005950927734e-01
+	.quad	0x3FC0D77E7CD08E59		# 1.31576299667358398438e-01
+	.quad	0x3FC29552F81FF523		# 1.45181953907012939453e-01
+	.quad	0x3FC44D2B6CCB7D1E		# 1.58604979515075683594e-01
+	.quad	0x3FC5FF3070A793D4		# 1.71850204467773437500e-01
+	.quad	0x3FC7AB890210D909		# 1.84922337532043457031e-01
+	.quad	0x3FC9525A9CF456B4		# 1.97825729846954345703e-01
+	.quad	0x3FCAF3C94E80BFF3		# 2.10564732551574707031e-01
+	.quad	0x3FCC8FF7C79A9A22		# 2.23143517971038818359e-01
+	.quad	0x3FCE27076E2AF2E6		# 2.35566020011901855469e-01
+	.quad	0x3FCFB9186D5E3E2B		# 2.47836112976074218750e-01
+	.quad	0x3FD0A324E27390E3		# 2.59957492351531982422e-01
+	.quad	0x3FD1675CABABA60E		# 2.71933674812316894531e-01
+	.quad	0x3FD22941FBCF7966		# 2.83768117427825927734e-01
+	.quad	0x3FD2E8E2BAE11D31		# 2.95464158058166503906e-01
+	.quad	0x3FD3A64C556945EA		# 3.07025015354156494141e-01
+	.quad	0x3FD4618BC21C5EC2		# 3.18453729152679443359e-01
+	.quad	0x3FD51AAD872DF82D		# 3.29753279685974121094e-01
+	.quad	0x3FD5D1BDBF5809CA		# 3.40926527976989746094e-01
+	.quad	0x3FD686C81E9B14AF		# 3.51976394653320312500e-01
+	.quad	0x3FD739D7F6BBD007		# 3.62905442714691162109e-01
+	.quad	0x3FD7EAF83B82AFC3		# 3.73716354370117187500e-01
+	.quad	0x3FD89A3386C1425B		# 3.84411692619323730469e-01
+	.quad	0x3FD947941C2116FB		# 3.94993782043457031250e-01
+	.quad	0x3FD9F323ECBF984C		# 4.05465066432952880859e-01
+	.quad	0x3FDA9CEC9A9A084A		# 4.15827870368957519531e-01
+	.quad	0x3FDB44F77BCC8F63		# 4.26084339618682861328e-01
+	.quad	0x3FDBEB4D9DA71B7C		# 4.36236739158630371094e-01
+	.quad	0x3FDC8FF7C79A9A22		# 4.46287095546722412109e-01
+	.quad	0x3FDD32FE7E00EBD5		# 4.56237375736236572266e-01
+	.quad	0x3FDDD46A04C1C4A1		# 4.66089725494384765625e-01
+	.quad	0x3FDE744261D68788		# 4.75845873355865478516e-01
+	.quad	0x3FDF128F5FAF06ED		# 4.85507786273956298828e-01
+	.quad	0x3FDFAF588F78F31F		# 4.95077252388000488281e-01
+	.quad	0x3FE02552A5A5D0FF		# 5.04556000232696533203e-01
+	.quad	0x3FE0723E5C1CDF40		# 5.13945698738098144531e-01
+	.quad	0x3FE0BE72E4252A83		# 5.23248136043548583984e-01
+	.quad	0x3FE109F39E2D4C97		# 5.32464742660522460938e-01
+	.quad	0x3FE154C3D2F4D5EA		# 5.41597247123718261719e-01
+	.quad	0x3FE19EE6B467C96F		# 5.50647079944610595703e-01
+	.quad	0x3FE1E85F5E7040D0		# 5.59615731239318847656e-01
+	.quad	0x3FE23130D7BEBF43		# 5.68504691123962402344e-01
+	.quad	0x3FE2795E1289B11B		# 5.77315330505371093750e-01
+	.quad	0x3FE2C0E9ED448E8C		# 5.86049020290374755859e-01
+	.quad	0x3FE307D7334F10BE		# 5.94707071781158447266e-01
+	.quad	0x3FE34E289D9CE1D3		# 6.03290796279907226562e-01
+	.quad	0x3FE393E0D3562A1A		# 6.11801505088806152344e-01
+	.quad	0x3FE3D9026A7156FB		# 6.20240390300750732422e-01
+	.quad	0x3FE41D8FE84672AE		# 6.28608644008636474609e-01
+	.quad	0x3FE4618BC21C5EC2		# 6.36907458305358886719e-01
+	.quad	0x3FE4A4F85DB03EBB		# 6.45137906074523925781e-01
+	.quad	0x3FE4E7D811B75BB1		# 6.53301239013671875000e-01
+	.quad	0x3FE52A2D265BC5AB		# 6.61398470401763916016e-01
+	.quad	0x3FE56BF9D5B3F399		# 6.69430613517761230469e-01
+	.quad	0x3FE5AD404C359F2D		# 6.77398800849914550781e-01
+	.quad	0x3FE5EE02A9241675		# 6.85303986072540283203e-01
+	.quad	0x3FE62E42FEFA39EF		# 6.93147122859954833984e-01
+	.quad 0					# for alignment
+
+.L__np_ln_lead_table:
+    .long 0x00000000  # 0.000000000000 0
+    .long 0x3C7E0000  # 0.015502929688 1
+    .long 0x3CFC1000  # 0.030769348145 2
+    .long 0x3D3BA000  # 0.045806884766 3
+    .long 0x3D785000  # 0.060623168945 4
+    .long 0x3D9A0000  # 0.075195312500 5
+    .long 0x3DB78000  # 0.089599609375 6
+    .long 0x3DD49000  # 0.103790283203 7
+    .long 0x3DF13000  # 0.117767333984 8
+    .long 0x3E06B000  # 0.131530761719 9
+    .long 0x3E14A000  # 0.145141601563 10
+    .long 0x3E226000  # 0.158569335938 11
+    .long 0x3E2FF000  # 0.171813964844 12
+    .long 0x3E3D5000  # 0.184875488281 13
+    .long 0x3E4A9000  # 0.197814941406 14
+    .long 0x3E579000  # 0.210510253906 15
+    .long 0x3E647000  # 0.223083496094 16
+    .long 0x3E713000  # 0.235534667969 17
+    .long 0x3E7DC000  # 0.247802734375 18
+    .long 0x3E851000  # 0.259887695313 19
+    .long 0x3E8B3000  # 0.271850585938 20
+    .long 0x3E914000  # 0.283691406250 21
+    .long 0x3E974000  # 0.295410156250 22
+    .long 0x3E9D3000  # 0.307006835938 23
+    .long 0x3EA30000  # 0.318359375000 24
+    .long 0x3EA8D000  # 0.329711914063 25
+    .long 0x3EAE8000  # 0.340820312500 26
+    .long 0x3EB43000  # 0.351928710938 27
+    .long 0x3EB9C000  # 0.362792968750 28
+    .long 0x3EBF5000  # 0.373657226563 29
+    .long 0x3EC4D000  # 0.384399414063 30
+    .long 0x3ECA3000  # 0.394897460938 31
+    .long 0x3ECF9000  # 0.405395507813 32
+    .long 0x3ED4E000  # 0.415771484375 33
+    .long 0x3EDA2000  # 0.426025390625 34
+    .long 0x3EDF5000  # 0.436157226563 35
+    .long 0x3EE47000  # 0.446166992188 36
+    .long 0x3EE99000  # 0.456176757813 37
+    .long 0x3EEEA000  # 0.466064453125 38
+    .long 0x3EF3A000  # 0.475830078125 39
+    .long 0x3EF89000  # 0.485473632813 40
+    .long 0x3EFD7000  # 0.494995117188 41
+    .long 0x3F012000  # 0.504394531250 42
+    .long 0x3F039000  # 0.513916015625 43
+    .long 0x3F05F000  # 0.523193359375 44
+    .long 0x3F084000  # 0.532226562500 45
+    .long 0x3F0AA000  # 0.541503906250 46
+    .long 0x3F0CF000  # 0.550537109375 47
+    .long 0x3F0F4000  # 0.559570312500 48
+    .long 0x3F118000  # 0.568359375000 49
+    .long 0x3F13C000  # 0.577148437500 50
+    .long 0x3F160000  # 0.585937500000 51
+    .long 0x3F183000  # 0.594482421875 52
+    .long 0x3F1A7000  # 0.603271484375 53
+    .long 0x3F1C9000  # 0.611572265625 54
+    .long 0x3F1EC000  # 0.620117187500 55
+    .long 0x3F20E000  # 0.628417968750 56
+    .long 0x3F230000  # 0.636718750000 57
+    .long 0x3F252000  # 0.645019531250 58
+    .long 0x3F273000  # 0.653076171875 59
+    .long 0x3F295000  # 0.661376953125 60
+    .long 0x3F2B5000  # 0.669189453125 61
+    .long 0x3F2D6000  # 0.677246093750 62
+    .long 0x3F2F7000  # 0.685302734375 63
+    .long 0x3F317000  # 0.693115234375 64
+    .long 0					# for alignment
+
+.L__np_ln_tail_table:
+    .long 0x00000000  # 0.000000000000 0
+    .long 0x35A8B0FC  # 0.000001256848 1
+    .long 0x361B0E78  # 0.000002310522 2
+    .long 0x3631EC66  # 0.000002651266 3
+    .long 0x35C30046  # 0.000001452871 4
+    .long 0x37EBCB0E  # 0.000028108738 5
+    .long 0x37528AE5  # 0.000012549314 6
+    .long 0x36DA7496  # 0.000006510479 7
+    .long 0x3783B715  # 0.000015701671 8
+    .long 0x383F3E68  # 0.000045596069 9
+    .long 0x38297C10  # 0.000040408282 10
+    .long 0x3815B666  # 0.000035694240 11
+    .long 0x38183854  # 0.000036292084 12
+    .long 0x38448108  # 0.000046850211 13
+    .long 0x373539E9  # 0.000010801924 14
+    .long 0x3864A740  # 0.000054515200 15
+    .long 0x387BE3CD  # 0.000060055219 16
+    .long 0x3803B715  # 0.000031403342 17
+    .long 0x380C36AF  # 0.000033429529 18
+    .long 0x3892713A  # 0.000069829126 19
+    .long 0x38AE55D6  # 0.000083129547 20
+    .long 0x38A0FDE8  # 0.000076766883 21
+    .long 0x3862BAE1  # 0.000054056643 22
+    .long 0x3798AAD3  # 0.000018199358 23
+    .long 0x38C5E10E  # 0.000094356117 24
+    .long 0x382D872E  # 0.000041372310 25
+    .long 0x38DEDFAC  # 0.000106274470 26
+    .long 0x38481E9B  # 0.000047712219 27
+    .long 0x38EBFB5E  # 0.000112524940 28
+    .long 0x38783B83  # 0.000059183232 29
+    .long 0x374E1B05  # 0.000012284848 30
+    .long 0x38CA0E11  # 0.000096347307 31
+    .long 0x3891F660  # 0.000069600297 32
+    .long 0x386C9A9A  # 0.000056410769 33
+    .long 0x38777BCD  # 0.000059004688 34
+    .long 0x38A6CED4  # 0.000079540216 35
+    .long 0x38FBE3CD  # 0.000120110439 36
+    .long 0x387E7E01  # 0.000060675669 37
+    .long 0x37D40984  # 0.000025276800 38
+    .long 0x3784C3AD  # 0.000015826745 39
+    .long 0x380F5FAF  # 0.000034182969 40
+    .long 0x38AC47BC  # 0.000082149607 41
+    .long 0x392952D3  # 0.000161479504 42
+    .long 0x37F97073  # 0.000029735476 43
+    .long 0x3865C84A  # 0.000054784388 44
+    .long 0x3979CF17  # 0.000238236375 45
+    .long 0x38C3D2F5  # 0.000093376184 46
+    .long 0x38E6B468  # 0.000110008579 47
+    .long 0x383EBCE1  # 0.000045475437 48
+    .long 0x39186BDF  # 0.000145360347 49
+    .long 0x392F0945  # 0.000166927537 50
+    .long 0x38E9ED45  # 0.000111545007 51
+    .long 0x396B99A8  # 0.000224685878 52
+    .long 0x37A27674  # 0.000019367064 53
+    .long 0x397069AB  # 0.000229275480 54
+    .long 0x39013539  # 0.000123222257 55
+    .long 0x3947F423  # 0.000190690669 56
+    .long 0x3945E10E  # 0.000188712234 57
+    .long 0x38F85DB0  # 0.000118430122 58
+    .long 0x396C08DC  # 0.000225100142 59
+    .long 0x37B4996F  # 0.000021529120 60
+    .long 0x397CEADA  # 0.000241200818 61
+    .long 0x3920261B  # 0.000152729845 62
+    .long 0x35AA4906  # 0.000001268724 63
+    .long 0x3805FDF4  # 0.000031946183 64
+    .long 0					# for alignment
+
diff --git a/src/gas/vrsapowf.S b/src/gas/vrsapowf.S
new file mode 100644
index 0000000..3521a6b
--- /dev/null
+++ b/src/gas/vrsapowf.S
@@ -0,0 +1,782 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrsapowf.asm
+#
+# An array implementation of the powf libm function.
+#
+# Prototype:
+#
+#     void vrsa_powf(int n, float *x, float *y, float *z);
+#
+#   Computes x raised to the y power.
+#
+#   Places the results into the supplied z array.
+# Does not perform error handling, but does return C99 values for error
+# inputs.   Denormal results are truncated to 0.
+
+#
+#
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+# define local variable storage offsets
+.equ	p_temp,0x00		# xmmword
+.equ	p_negateres,0x10		# qword
+
+
+.equ	save_rbx,0x030		#qword
+
+
+.equ	p_ax,0x050		# absolute x
+.equ	p_sx,0x060		# sign of x's
+
+.equ	p_ay,0x070		# absolute y
+.equ	p_yexp,0x080		# unbiased exponent of y
+
+.equ	p_inty,0x090		# integer y indicators
+
+.equ	p_xptr,0x0a0		# ptr to x values
+.equ	p_yptr,0x0a8		# ptr to y values
+.equ	p_zptr,0x0b0		# ptr to z values
+
+.equ	p_nv,0x0b8		#qword
+.equ	p_iter,0x0c0		# qword	storage for number of loop iterations
+
+.equ	p2_temp,0x0d0		#qword
+.equ	p2_temp1,0x0f0		#qword
+
+.equ	stack_size,0x0118	# allocate 40h more than
+				# we need to avoid bank conflicts
+
+
+
+
+        .weak vrsa_powf_
+        .set vrsa_powf_,__vrsa_powf__
+        .weak vrsa_powf__
+        .set vrsa_powf__,__vrsa_powf__
+
+    .text
+    .align 16
+    .p2align 4,,15
+
+#/* a FORTRAN subroutine implementation of array powf
+#**     VRSA_POWF(N,X,Y,Z)
+#** C equivalent
+#*/
+#void vrsa_powf_(int * n, float *x, float *y, float *z)
+#{
+#       vrsa_powf(*n,x,y,z);
+#}
+
+.globl __vrsa_powf__
+    .type   __vrsa_powf__,@function
+__vrsa_powf__:
+	mov		(%rdi),%edi
+
+
+# parameters are passed in by Linux as:
+# edi - int    n
+# rsi - float *x
+# rdx - float *y
+# rcx - float *z
+
+.globl vrsa_powf
+    .type   vrsa_powf,@function
+vrsa_powf:
+
+	sub		$stack_size,%rsp
+	mov		%rbx,save_rbx(%rsp)	# save rbx
+# save the arguments
+	mov		  %rsi,p_xptr(%rsp)		# save pointer to x
+	mov		  %rdx,p_yptr(%rsp)		# save pointer to y
+	mov		  %rcx,p_zptr(%rsp)		# save pointer to z
+#ifdef INTEGER64
+        mov             %rdi,%rax
+#else
+        mov             %edi,%eax
+#endif
+
+	mov     %rax,%rcx
+	mov		%rcx,p_nv(%rsp)	# save number of values
+# see if too few values to call the main loop
+	shr		$2,%rax						# get number of iterations
+	jz		.L__vsa_cleanup				# jump if only single calls
+# prepare the iteration counts
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	shl		$2,%rax
+	sub		%rax,%rcx						# compute number of extra single calls
+	mov		%rcx,p_nv(%rsp)	# save number of left over values
+
+# process the array 4 values at a time.
+
+.L__vsa_top:
+# build the input _m128
+# first get x
+	mov		p_xptr(%rsp),%rsi	# get x_array pointer
+	movups	(%rsi),%xmm0
+	prefetch	64(%rsi)
+
+	movaps	%xmm0,%xmm2
+	andps	.L__mask_nsign(%rip),%xmm0		# get abs x
+	andps	.L__mask_sign(%rip),%xmm2			# mask for the sign bits
+	movaps	  %xmm0,p_ax(%rsp)		# save them
+	movaps	  %xmm2,p_sx(%rsp)		# save them
+# convert all four x's to double
+	cvtps2pd   p_ax(%rsp),%xmm0
+	cvtps2pd   p_ax+8(%rsp),%xmm1
+#
+# classify y
+# vector 32 bit integer method	 25 cycles to here
+#  /* See whether y is an integer.
+#     inty = 0 means not an integer.
+#     inty = 1 means odd integer.
+#     inty = 2 means even integer.
+#  */
+	mov		p_yptr(%rsp),%rdi	# get y_array pointer
+	movups  (%rdi),%xmm4
+	prefetch	64(%rdi)
+	pxor	%xmm3,%xmm3
+	pand	.L__mask_nsign(%rip),%xmm4		# get abs y in integer format
+	movdqa    %xmm4,p_ay(%rsp)			# save it
+
+# see if the number is less than 1.0
+	psrld	$23,%xmm4			#>> EXPSHIFTBITS_SP32
+
+	psubd	.L__mask_127(%rip),%xmm4			# yexp, unbiased exponent
+	movdqa    %xmm4,p_yexp(%rsp)		# save it
+	paddd	.L__mask_1(%rip),%xmm4			# yexp+1
+	pcmpgtd	%xmm3,%xmm4		# 0 if exp less than 126 (2^0) (y < 1.0), else FFs
+# xmm4 is ffs if abs(y) >=1.0, else 0
+
+# see if the mantissa has fractional bits
+#build mask for mantissa
+	movdqa  .L__mask_23(%rip),%xmm2
+	psubd	p_yexp(%rsp),%xmm2		# 24-yexp
+	pmaxsw	%xmm3,%xmm2							# no shift counts less than 0
+	movdqa    %xmm2,p_temp(%rsp)		# save the shift counts
+# create mask for all four values
+# SSE can't individual shifts so have to do 0xeac one seperately
+	mov		p_temp(%rsp),%rcx
+	mov		$1,%rbx
+	shl		%cl,%ebx			#1 << (24 - yexp)
+	shr		$32,%rcx
+	mov		$1,%eax
+	shl		%cl,%eax			#1 << (24 - yexp)
+	shl		$32,%rax
+	add		%rax,%rbx
+	mov		%rbx,p_temp(%rsp)
+	mov		p_temp+8(%rsp),%rcx
+	mov		$1,%rbx
+	shl		%cl,%ebx			#1 << (24 - yexp)
+	shr		$32,%rcx
+	mov		$1,%eax
+	shl		%cl,%eax			#1 << (24 - yexp)
+	shl		$32,%rax
+	add		%rbx,%rax
+	mov		  %rax,p_temp+8(%rsp)
+	movdqa  p_temp(%rsp),%xmm5
+	psubd	.L__mask_1(%rip),%xmm5	#= mask = (1 << (24 - yexp)) - 1
+
+# now use the mask to see if there are any fractional bits
+	movdqu  (%rdi),%xmm2 # get uy
+	pand	%xmm5,%xmm2		# uy & mask
+	pcmpeqd	%xmm3,%xmm2		# 0 if not zero (y has fractional mantissa bits), else FFs
+	pand	%xmm4,%xmm2		# either 0s or ff
+# xmm2 now accounts for y< 1.0 or y>=1.0 and y has fractional mantissa bits,
+# it has the value 0 if we know it's non-integer or ff if integer.
+
+# now see if it's even or odd.
+
+## if yexp > 24, then it has to be even
+	movdqa  .L__mask_24(%rip),%xmm4
+	psubd	p_yexp(%rsp),%xmm4		# 24-yexp
+	paddd	.L__mask_1(%rip),%xmm5	# mask+1 = least significant integer bit
+	pcmpgtd	%xmm3,%xmm4		 # if 0, then must be even, else ff's
+
+ 	pand	%xmm4,%xmm5		# set the integer bit mask to zero if yexp>24
+ 	paddd	.L__mask_2(%rip),%xmm4
+ 	por		.L__mask_2(%rip),%xmm4
+ 	pand	%xmm2,%xmm4		 # result can be 0, 2, or 3
+
+# now for integer numbers, see if odd or even
+	pand	.L__mask_mant(%rip),%xmm5	# mask out exponent bits
+	movdqu (%rdi),%xmm2
+	pand    %xmm2,%xmm5 #  & uy -> even or odd
+	movdqa	.L__float_one(%rip),%xmm2
+	pcmpeqd	p_ay(%rsp),%xmm2	# is ay equal to 1, ff's if so, then it's odd
+	pand	.L__mask_nsign(%rip),%xmm2 # strip the sign bit so the gt comparison works.
+	por		%xmm2,%xmm5
+	pcmpgtd	%xmm3,%xmm5		 # if odd then ff's, else 0's for even
+	paddd	.L__mask_2(%rip),%xmm5 # gives us 2 for even, 1 for odd
+	pand	%xmm5,%xmm4
+
+	movdqa		  %xmm4,p_inty(%rsp)		# save inty
+#
+# do more x special case checking
+#
+	movdqa	%xmm4,%xmm5
+	pcmpeqd	%xmm3,%xmm5						# is not an integer? ff's if so
+	pand	.L__mask_NaN(%rip),%xmm5		# these values will be NaNs, if x<0
+	movdqa	%xmm4,%xmm2
+	pcmpeqd	.L__mask_1(%rip),%xmm2		# is it odd? ff's if so
+	pand	.L__mask_sign(%rip),%xmm2	# these values will get their sign bit set
+	por		%xmm2,%xmm5
+
+	pcmpeqd	p_sx(%rsp),%xmm3		# if the signs are set
+	pandn	%xmm5,%xmm3						# then negateres gets the values as shown below
+	movdqa	  %xmm3,p_negateres(%rsp)	# save negateres
+
+#  /* p_negateres now means the following.
+#     7FC00000 means x<0, y not an integer, return NaN.
+#     80000000 means x<0, y is odd integer, so set the sign bit.
+##     0 means even integer, and/or x>=0.
+#  */
+
+
+# **** Here starts the main calculations  ****
+# The algorithm used is x**y = exp(y*log(x))
+#  Extra precision is required in intermediate steps to meet the 1ulp requirement
+#
+# log(x) calculation
+	call		__vrd4_log@PLT					# get the double precision log value
+											# for all four x's
+# y* logx
+# convert all four y's to double
+#	mov	p_yptr(%rsp),%rdi		; get y_array pointer
+	cvtps2pd   (%rdi),%xmm2
+	cvtps2pd   8(%rdi),%xmm3
+
+#  /* just multiply by y */
+	mulpd	%xmm2,%xmm0
+	mulpd	%xmm3,%xmm1
+
+#  /* The following code computes r = exp(w) */
+	call		__vrd4_exp@PLT		# get the double exp value
+						# for all four y*log(x)'s
+	mov		p_xptr(%rsp),%rsi	# get x_array pointer
+	mov		p_yptr(%rsp),%rdi	# get y_array pointer
+#
+# convert all four results to double
+	cvtpd2ps	%xmm0,%xmm0
+	cvtpd2ps	%xmm1,%xmm1
+	movlhps		%xmm1,%xmm0
+
+# perform special case and error checking on input values
+
+# special case checking is done first in the scalar version since
+# it allows for early fast returns.  But for vectors, we consider them
+# to be rare, so early returns are not necessary.  So we first compute
+# the x**y values, and then check for special cases.
+
+# we do some of the checking in reverse order of the scalar version.
+# apply the negate result flags
+	orps	p_negateres(%rsp),%xmm0	# get negateres
+
+## if y is infinite or so large that the result would overflow or underflow
+	movdqa	p_ay(%rsp),%xmm4
+	cmpps	$5,.L__mask_ly(%rip),%xmm4	# y not less than large value, ffs if so.
+	movmskps %xmm4,%edx
+	test	$0x0f,%edx
+	jnz		.Ly_large
+.Lrnsx3:
+
+## if x is infinite
+	movdqa	p_ax(%rsp),%xmm4
+	cmpps	$0,.L__mask_inf(%rip),%xmm4	# equal to infinity, ffs if so.
+	movmskps %xmm4,%edx
+	test	$0x0f,%edx
+	jnz		.Lx_infinite
+.Lrnsx1:
+## if x is zero
+	xorps	%xmm4,%xmm4
+	cmpps	$0,p_ax(%rsp),%xmm4	# equal to zero, ffs if so.
+	movmskps %xmm4,%edx
+	test	$0x0f,%edx
+	jnz		.Lx_zero
+.Lrnsx2:
+## if y is NAN
+	movdqu	(%rdi),%xmm4		# get y
+	cmpps	$4,%xmm4,%xmm4		# a compare not equal  of y to itself should
+					# be false, unless y is a NaN. ff's if NaN.
+	movmskps %xmm4,%ecx
+	test	$0x0f,%ecx
+	jnz		.Ly_NaN
+.Lrnsx4:
+## if x is NAN
+	movdqu	(%rsi),%xmm4		# get x
+	cmpps	$4,%xmm4,%xmm4		# a compare not equal  of x to itself should
+					# be false, unless x is a NaN. ff's if NaN.
+	movmskps %xmm4,%ecx
+	test	$0x0f,%ecx
+	jnz		.Lx_NaN
+.Lrnsx5:
+
+## if |y| == 0	then return 1
+	movdqa	.L__float_one(%rip),%xmm3	# one
+	xorps	%xmm2,%xmm2
+	cmpps	$4,p_ay(%rsp),%xmm2	# not equal to 0.0?, ffs if not equal.
+	andps	%xmm2,%xmm0		# keep the others
+	andnps	%xmm3,%xmm2		# mask for ones
+	orps	%xmm2,%xmm0
+## if x == +1, return +1 for all x
+	movdqa	%xmm3,%xmm2
+	movdqu	(%rsi),%xmm5
+	cmpps	$4,%xmm5,%xmm2		# not equal to +1.0?, ffs if not equal.
+	andps	%xmm2,%xmm0		# keep the others
+	andnps	%xmm3,%xmm2		# mask for ones
+	orps	%xmm2,%xmm0
+
+.L__powf_cleanup2:
+
+# update the x and y pointers
+	add		$16,%rdi
+	add		$16,%rsi
+	mov		%rsi,p_xptr(%rsp)	# save x_array pointer
+	mov		%rdi,p_yptr(%rsp)	# save y_array pointer
+# store the result _m128d
+	mov		p_zptr(%rsp),%rdi	# get z_array pointer
+	movups	%xmm0,(%rdi)
+#	prefetchw	QWORD PTR [rdi+64]
+	prefetch	64(%rdi)
+	add		$16,%rdi
+	mov		%rdi,p_zptr(%rsp)	# save z_array pointer
+
+
+	mov		p_iter(%rsp),%rax	# get number of iterations
+	sub		$1,%rax
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	jnz		.L__vsa_top
+
+
+# see if we need to do any extras
+	mov		p_nv(%rsp),%rax	# get number of values
+	test	%rax,%rax
+	jnz		.L__vsa_cleanup
+
+.L__final_check:
+	mov		save_rbx(%rsp),%rbx		# restore rbx
+	add		$stack_size,%rsp
+	ret
+
+	.align 16
+# we jump here when we have an odd number of log calls to make at the
+# end
+.L__vsa_cleanup:
+        mov             p_nv(%rsp),%rax      # get number of values
+        test            %rax,%rax               # are there any values
+        jz              .L__final_check         # exit if not
+
+	mov		p_xptr(%rsp),%rsi
+	mov		p_yptr(%rsp),%rdi
+
+# fill in a m128 with zeroes and the extra values and then make a recursive call.
+	xorps		%xmm0,%xmm0
+	movaps	  %xmm0,p2_temp(%rsp)
+	movaps	  %xmm0,p2_temp+16(%rsp)
+
+	mov		(%rsi),%ecx			# we know there's at least one
+	mov	 	%ecx,p2_temp(%rsp)
+	mov		(%rdi),%edx			# we know there's at least one
+	mov	 	%edx,p2_temp+16(%rsp)
+	cmp		$2,%rax
+	jl		.L__vsacg
+
+	mov		4(%rsi),%ecx			# do the second value
+	mov	 	%ecx,p2_temp+4(%rsp)
+	mov		4(%rdi),%edx			# we know there's at least one
+	mov	 	%edx,p2_temp+20(%rsp)
+	cmp		$3,%rax
+	jl		.L__vsacg
+
+	mov		8(%rsi),%ecx			# do the third value
+	mov	 	%ecx,p2_temp+8(%rsp)
+	mov		8(%rdi),%edx			# we know there's at least one
+	mov	 	%edx,p2_temp+24(%rsp)
+
+.L__vsacg:
+	mov		$4,%rdi				# parameter for N
+	lea		p2_temp(%rsp),%rsi	# &x parameter
+	lea		p2_temp+16(%rsp),%rdx	# &y parameter
+	lea		p2_temp1(%rsp),%rcx	# &z parameter
+	call	vrsa_powf@PLT			# call recursively to compute four values
+
+# now copy the results to the destination array
+	mov		p_zptr(%rsp),%rdi
+	mov		p_nv(%rsp),%rax	# get number of values
+	mov	 	p2_temp1(%rsp),%ecx
+	mov		%ecx,(%rdi)			# we know there's at least one
+	cmp		$2,%rax
+	jl		.L__vsacgf
+
+	mov	 	p2_temp1+4(%rsp),%ecx
+	mov		%ecx,4(%rdi)			# do the second value
+	cmp		$3,%rax
+	jl		.L__vsacgf
+
+	mov	 	p2_temp1+8(%rsp),%ecx
+	mov		%ecx,8(%rdi)			# do the third value
+
+.L__vsacgf:
+	jmp		.L__final_check
+
+	.align 16
+#      y is a NaN.
+.Ly_NaN:
+	mov		p_yptr(%rsp),%rdx		# get pointer to y
+	movdqu	(%rdx),%xmm4			# get y
+	movdqa	%xmm4,%xmm3
+	movdqa	%xmm4,%xmm5
+	movdqa	.L__mask_sigbit(%rip),%xmm2	# get the signalling bits
+	cmpps	$0,%xmm4,%xmm4			# a compare equal  of y to itself should
+						# be true, unless y is a NaN. 0's if NaN.
+	cmpps	$4,%xmm3,%xmm3			# compare not equal, ff's if NaN.
+	andps	%xmm4,%xmm0			# keep the other results
+	andps	%xmm3,%xmm2			# get just the right signalling bits
+	andps	%xmm5,%xmm3			# mask for the NaNs
+	orps	%xmm2,%xmm3			# convert to QNaNs
+	orps	%xmm3,%xmm0			# combine
+	jmp	   	.Lrnsx4
+
+#       y is a NaN.
+.Lx_NaN:
+	mov		p_xptr(%rsp),%rcx	# get pointer to x
+	movdqu	(%rcx),%xmm4			# get x
+	movdqa	%xmm4,%xmm3
+	movdqa	%xmm4,%xmm5
+	movdqa	.L__mask_sigbit(%rip),%xmm2	# get the signalling bits
+	cmpps	$0,%xmm4,%xmm4			# a compare equal  of x to itself should
+						# be true, unless x is a NaN. 0's if NaN.
+	cmpps	$4,%xmm3,%xmm3			# compare not equal, ff's if NaN.
+	andps	%xmm4,%xmm0			# keep the other results
+	andps	%xmm3,%xmm2			# get just the right signalling bits
+	andps	%xmm5,%xmm3			# mask for the NaNs
+	orps	%xmm2,%xmm3	# convert to QNaNs
+	orps	%xmm3,%xmm0						# combine
+	jmp	   	.Lrnsx5
+
+#       y is infinite or so large that the result would
+#         overflow or underflow.
+.Ly_large:
+	movdqa	  %xmm0,p_temp(%rsp)
+
+	test	$1,%edx
+	jz		.Lylrga
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		p_yptr(%rsp),%rbx		# get pointer to y
+	mov		(%rcx),%eax
+	mov		(%rbx),%ebx
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special6				# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp(%rsp)
+.Lylrga:
+	test	$2,%edx
+	jz		.Lylrgb
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		p_yptr(%rsp),%rbx		# get pointer to y
+	mov		4(%rcx),%eax
+	mov		4(%rbx),%ebx
+	mov		p_inty+4(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special6				# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+4(%rsp)
+.Lylrgb:
+	test	$4,%edx
+	jz		.Lylrgc
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		p_yptr(%rsp),%rbx		# get pointer to y
+	mov		8(%rcx),%eax
+	mov		8(%rbx),%ebx
+	mov		p_inty+8(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special6				# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+8(%rsp)
+.Lylrgc:
+	test	$8,%edx
+	jz		.Lylrgd
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		p_yptr(%rsp),%rbx		# get pointer to y
+	mov		12(%rcx),%eax
+	mov		12(%rbx),%ebx
+	mov		p_inty+12(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special6				# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+12(%rsp)
+.Lylrgd:
+	movdqa	p_temp(%rsp),%xmm0
+	jmp 	.Lrnsx3
+
+# a subroutine to treat an individual x,y pair when y is large or infinity
+# assumes x in .Ly(%rip),%eax in ebx.
+# returns result in eax
+.Lnp_special6:
+# handle |x|==1 cases first
+	mov		$0x07FFFFFFF,%r8d
+	and		%eax,%r8d
+	cmp		$0x03f800000,%r8d		  # jump if |x| !=1
+	jnz		.Lnps6
+	mov		$0x03f800000,%eax		  # return 1 for all |x|==1
+	jmp 	.Lnpx64
+
+# cases where  |x| !=1
+.Lnps6:
+	mov		$0x07f800000,%ecx
+	xor		%eax,%eax							  # assume 0 return
+	test	$0x080000000,%ebx
+	jnz		.Lnps62				  # jump if y negative
+# y = +inf
+	cmp		$0x03f800000,%r8d
+	cmovg	%ecx,%eax				  # return inf if |x| < 1
+	jmp 	.Lnpx64
+.Lnps62:
+# y = -inf
+	cmp		$0x03f800000,%r8d
+	cmovl	%ecx,%eax				  # return inf if |x| < 1
+	jmp 	.Lnpx64
+
+.Lnpx64:
+	ret
+
+# handle cases where x is +/- infinity.  edx is the mask
+	.align 16
+.Lx_infinite:
+	movdqa	  %xmm0,p_temp(%rsp)
+
+	test	$1,%edx
+	jz		.Lxinfa
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		p_yptr(%rsp),%rbx		# get pointer to y
+	mov		(%rcx),%eax
+	mov		(%rbx),%ebx
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x1				# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp(%rsp)
+.Lxinfa:
+	test	$2,%edx
+	jz		.Lxinfb
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		p_yptr(%rsp),%rbx		# get pointer to y
+	mov		4(%rcx),%eax
+	mov		4(%rbx),%ebx
+	mov		p_inty+4(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x1				# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+4(%rsp)
+.Lxinfb:
+	test	$4,%edx
+	jz		.Lxinfc
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		p_yptr(%rsp),%rbx		# get pointer to y
+	mov		8(%rcx),%eax
+	mov		8(%rbx),%ebx
+	mov		p_inty+8(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x1				# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+8(%rsp)
+.Lxinfc:
+	test	$8,%edx
+	jz		.Lxinfd
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		p_yptr(%rsp),%rbx		# get pointer to y
+	mov		12(%rcx),%eax
+	mov		12(%rbx),%ebx
+	mov		p_inty+12(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x1				# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+12(%rsp)
+.Lxinfd:
+	movdqa	p_temp(%rsp),%xmm0
+	jmp 	.Lrnsx1
+
+# a subroutine to treat an individual x,y pair when x is +/-infinity
+# assumes x in .Ly(%rip),%eax in ebx, inty in ecx.
+# returns result in eax
+.Lnp_special_x1:				# x is infinite
+	test	$0x080000000,%eax		# is x positive
+	jnz		.Lnsx11			# jump if not
+	test	$0x080000000,%ebx		# is y positive
+	jz		.Lnsx13			# just return if so
+	xor		%eax,%eax		# else return 0
+	jmp 	.Lnsx13
+
+.Lnsx11:
+	cmp		$1,%ecx			# if inty ==1
+	jnz		.Lnsx12			# jump if not
+	test	$0x080000000,%ebx		# is y positive
+	jz		.Lnsx13			# just return if so
+	mov		$0x080000000,%eax	# else return -0
+	jmp 	.Lnsx13
+.Lnsx12:					# inty <>1
+	and		$0x07FFFFFFF,%eax	# return -x (|x|)  if y<0
+	test	$0x080000000,%ebx		# is y positive
+	jz		.Lnsx13			#
+	xor		%eax,%eax		# return 0  if y >=0
+.Lnsx13:
+	ret
+
+
+# handle cases where x is +/- zero.  edx is the mask of x,y pairs with |x|=0
+	.align 16
+.Lx_zero:
+	movdqa	  %xmm0,p_temp(%rsp)
+
+	test	$1,%edx
+	jz		.Lxzera
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		p_yptr(%rsp),%rbx		# get pointer to y
+	mov		(%rcx),%eax
+	mov		(%rbx),%ebx
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x2				# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp(%rsp)
+.Lxzera:
+	test	$2,%edx
+	jz		.Lxzerb
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		p_yptr(%rsp),%rbx		# get pointer to y
+	mov		4(%rcx),%eax
+	mov		4(%rbx),%ebx
+	mov		p_inty+4(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x2				# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+4(%rsp)
+.Lxzerb:
+	test	$4,%edx
+	jz		.Lxzerc
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		p_yptr(%rsp),%rbx		# get pointer to y
+	mov		8(%rcx),%eax
+	mov		8(%rbx),%ebx
+	mov		p_inty+8(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x2				# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+8(%rsp)
+.Lxzerc:
+	test	$8,%edx
+	jz		.Lxzerd
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		p_yptr(%rsp),%rbx		# get pointer to y
+	mov		12(%rcx),%eax
+	mov		12(%rbx),%ebx
+	mov		p_inty+12(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x2				# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+12(%rsp)
+.Lxzerd:
+	movdqa	p_temp(%rsp),%xmm0
+	jmp 	.Lrnsx2
+
+# a subroutine to treat an individual x,y pair when x is +/-0
+# assumes x in .Ly(%rip),%eax in ebx, inty in ecx.
+# returns result in eax
+	.align 16
+.Lnp_special_x2:
+	cmp		$1,%ecx				# if inty ==1
+	jz		.Lnsx21				# jump if so
+# handle cases of x=+/-0, y not integer
+	xor		%eax,%eax
+	mov		$0x07f800000,%ecx
+	test	$0x080000000,%ebx			# is ypos
+	cmovnz	%ecx,%eax
+	jmp		.Lnsx23
+# y is an integer
+.Lnsx21:
+	xor		%r8d,%r8d
+	mov		$0x07f800000,%ecx
+	test	$0x080000000,%ebx			# is ypos
+	cmovnz	%ecx,%r8d				# set to infinity if not
+	and		$0x080000000,%eax		# pickup the sign of x
+	or		%r8d,%eax			# and include it in the result
+.Lnsx23:
+	ret
+
+
+
+        .data
+        .align 64
+
+.L__mask_sign:                  .quad 0x08000000080000000       # a sign bit mask
+                                .quad 0x08000000080000000
+
+.L__mask_nsign:                 .quad 0x07FFFFFFF7FFFFFFF       # a not sign bit mask
+                                .quad 0x07FFFFFFF7FFFFFFF
+
+# used by inty
+.L__mask_127:                   .quad 0x00000007F0000007F       # EXPBIAS_SP32
+                                .quad 0x00000007F0000007F
+
+.L__mask_mant:                  .quad 0x0007FFFFF007FFFFF       # mantissa bit mask
+                                .quad 0x0007FFFFF007FFFFF
+
+.L__mask_1:                     .quad 0x00000000100000001       # 1
+                                .quad 0x00000000100000001
+
+.L__mask_2:                     .quad 0x00000000200000002       # 2
+                                .quad 0x00000000200000002
+
+.L__mask_24:                    .quad 0x00000001800000018       # 24
+                                .quad 0x00000001800000018
+
+.L__mask_23:                    .quad 0x00000001700000017       # 23
+                                .quad 0x00000001700000017
+
+# used by special case checking
+
+.L__float_one:                  .quad 0x03f8000003f800000       # one
+                                .quad 0x03f8000003f800000
+
+.L__mask_inf:                   .quad 0x07f8000007F800000       # inifinity
+                                .quad 0x07f8000007F800000
+
+.L__mask_NaN:                   .quad 0x07fC000007FC00000       # NaN
+                                .quad 0x07fC000007FC00000
+
+.L__mask_sigbit:                .quad 0x00040000000400000       # QNaN bit
+                                .quad 0x00040000000400000
+
+.L__mask_ly:                    .quad 0x04f0000004f000000       # large y
+                                .quad 0x04f0000004f000000
+
+
diff --git a/src/gas/vrsapowxf.S b/src/gas/vrsapowxf.S
new file mode 100644
index 0000000..4f67daf
--- /dev/null
+++ b/src/gas/vrsapowxf.S
@@ -0,0 +1,753 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrsapowxf.asm
+#
+# An array implementation of the powf libm function.
+# This routine raises the x array to a constant y power.
+#
+# Prototype:
+#
+#     void vrsa_powxf(int n, float *x, float y, float *z);
+#
+#   Places the results into the supplied z array.
+# Does not perform error handling, but does return C99 values for error
+# inputs.   Denormal results are truncated to 0.
+#
+#
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+
+# define local variable storage offsets
+.equ	p_temp,0x00		# xmmword
+.equ	p_negateres,0x10		# qword
+
+.equ	p_xexp,0x20		# qword
+
+.equ	save_rbx,0x030		#qword
+
+.equ	p_y,0x048		# y value
+
+.equ	p_ax,0x050		# absolute x
+.equ	p_sx,0x060		# sign of x's
+
+.equ	p_ay,0x070		# absolute y
+.equ	p_yexp,0x080		# unbiased exponent of y
+
+.equ	p_inty,0x090		# integer y indicator
+
+.equ	p_xptr,0x0a0		# ptr to x values
+.equ	p_zptr,0x0b0		# ptr to z values
+
+.equ	p_nv,0x0b8		#qword
+.equ	p_iter,0x0c0		# qword	storage for number of loop iterations
+
+.equ	p2_temp,0x0d0		#qword
+.equ	p2_temp1,0x0f0		#qword
+
+.equ	stack_size,0x0118	# allocate 40h more than
+								# we need to avoid bank conflicts
+
+
+
+
+     .weak vrsa_powxf_
+     .set vrsa_powxf_,__vrsa_powxf__
+     .weak vrsa_powxf__
+     .set vrsa_powxf__,__vrsa_powxf__
+
+    .text
+    .align 16
+    .p2align 4,,15
+.globl __vrsa_powxf__
+    .type   __vrsa_powxf__,@function
+__vrsa_powxf__:
+
+#/* a FORTRAN subroutine implementation of array powf
+#**     VRSA_POWXF(N,X,Y,Z)
+#** C equivalent
+#*/
+#void vrsa_powxf_(int * n, float *x, float *y, float *z)
+#{
+#       vrsa_powxf(*n,x,y,z);
+#}
+# parameters are passed in by Linux FORTRAN  as:
+# edi  - int    n
+# rsi  - float *x
+# rdx  - float *y
+# rcx  - float *z
+        mov             (%rdi),%edi
+        movss           (%rdx),%xmm0
+        mov             %rcx,%rdx
+
+
+
+
+# parameters are passed in by Linux C as:
+# edi  - int    n
+# rsi  - float *x
+# xmm0 - float y
+# rdx  - float *z
+
+.globl vrsa_powxf
+    .type   vrsa_powxf,@function
+vrsa_powxf:
+
+	sub		$stack_size,%rsp
+	mov		%rbx,save_rbx(%rsp)	# save rbx
+
+	movss	  %xmm0,p_y(%rsp)		# save y
+	mov		  %rsi,p_xptr(%rsp)		# save pointer to x
+	mov		  %rdx,p_zptr(%rsp)		# save pointer to z
+#ifdef INTEGER64
+        mov             %rdi,%rax
+#else
+        mov             %edi,%eax
+#endif
+	test		%rax,%rax		# just return if count is zero
+        jz              .L__final_check         # exit if not
+
+	mov     %rax,%rcx
+	mov		%rcx,p_nv(%rsp)	# save number of values
+
+#
+# classify y
+# vector 32 bit integer method
+#  /* See whether y is an integer.
+#     inty = 0 means not an integer.
+#     inty = 1 means odd integer.
+#     inty = 2 means even integer.
+#  */
+#	movdqa  .LXMMWORD(%rip),%xmm4 PTR [rdx]
+# get yexp
+	mov		p_y(%rsp),%r8d						# r8 is uy
+	mov		$0x07fffffff,%r9d
+	and		%r8d,%r9d						# r9 is ay
+
+## if |y| == 0	then return 1
+	cmp		$0,%r9d			# is y a zero?
+	jz		.Ly_zero
+
+	mov		$0x07f800000,%eax				# EXPBITS_SP32
+	and		%r9d,%eax						# y exp
+
+	xor		%edi,%edi
+	shr		$23,%eax			#>> EXPSHIFTBITS_SP32
+	sub		$126,%eax		# - EXPBIAS_SP32 + 1   - eax is now the unbiased exponent
+	mov		$1,%ebx
+	cmp		%ebx,%eax			# if (yexp < 1)
+	cmovl	%edi,%ebx
+	jl		.Lsave_inty
+
+	mov		$24,%ecx
+	cmp		%ecx,%eax			# if (yexp >24)
+	jle		.Lcly1
+	mov		$2,%ebx
+	jmp		.Lsave_inty
+.Lcly1:							# else 1<=yexp<=24
+	sub		%eax,%ecx			# build mask for mantissa
+	shl		%cl,%ebx
+	dec		%ebx				# rbx = mask = (1 << (24 - yexp)) - 1
+
+	mov		%r8d,%eax
+	and		%ebx,%eax			# if ((uy & mask) != 0)
+	cmovnz	%edi,%ebx			#   inty = 0;
+	jnz		.Lsave_inty
+
+	not		%ebx				# else if (((uy & ~mask) >> (24 - yexp)) & 0x00000001)
+	mov		%r8d,%eax
+	and		%ebx,%eax
+	shr		%cl,%eax
+	inc		%edi
+	and		%edi,%eax
+	mov		%edi,%ebx			#  inty = 1
+	jnz		.Lsave_inty
+	inc		%ebx				# else	inty = 2
+
+
+.Lsave_inty:
+	mov		 %r8d,p_y+4(%rsp)		# save an extra copy of y
+	mov		 %ebx,p_inty(%rsp)		# save inty
+
+	mov		p_nv(%rsp),%rax	# get number of values
+	mov     %rax,%rcx
+# see if too few values to call the main loop
+	shr		$2,%rax						# get number of iterations
+	jz		.L__vsa_cleanup				# jump if only single calls
+# prepare the iteration counts
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	shl		$2,%rax
+	sub		%rax,%rcx						# compute number of extra single calls
+	mov		%rcx,p_nv(%rsp)	# save number of left over values
+
+# process the array 4 values at a time.
+
+.L__vsa_top:
+# build the input _m128
+# first get x
+	mov		p_xptr(%rsp),%rsi	# get x_array pointer
+	movups	(%rsi),%xmm0
+	prefetch	64(%rsi)
+
+
+	movaps	%xmm0,%xmm2
+	andps	.L__mask_nsign(%rip),%xmm0		# get abs x
+	andps	.L__mask_sign(%rip),%xmm2			# mask for the sign bits
+	movaps	  %xmm0,p_ax(%rsp)		# save them
+	movaps	  %xmm2,p_sx(%rsp)		# save them
+# convert all four x's to double
+	cvtps2pd   p_ax(%rsp),%xmm0
+	cvtps2pd   p_ax+8(%rsp),%xmm1
+#
+# do x special case checking
+#
+#	movdqa	%xmm4,%xmm5
+#	pcmpeqd	%xmm3,%xmm5						; is y not an integer? ff's if so
+#	pand	.LXMMWORD(%rip),%xmm5 PTR __mask_NaN		; these values will be NaNs, if x<0
+	pxor	%xmm3,%xmm3
+	xor		%eax,%eax
+	mov		$0x07FC00000,%ecx
+	cmp		$0,%ebx							# is y not an integer?
+	cmovz	%ecx,%eax							# then set to return a NaN.  else 0.
+	mov		$0x080000000,%ecx
+	cmp		$1,%ebx							# is y an odd integer?
+	cmovz	%ecx,%eax							# maybe set sign bit if so
+	movd	%eax,%xmm5
+	pshufd	$0,%xmm5,%xmm5
+#	shufps	xmm5,%xmm5
+#	movdqa	%xmm4,%xmm2
+#	pcmpeqd	.LXMMWORD(%rip),%xmm2 PTR __mask_1		; is it odd? ff's if so
+#	pand	.LXMMWORD(%rip),%xmm2 PTR __mask_sign	; these values might get their sign bit set
+#	por		%xmm2,%xmm5
+
+#	cmpps	xmm3,XMMWORD PTR p_sx[rsp],0	; if the signs are set
+	pcmpeqd	p_sx(%rsp),%xmm3		# if the signs are set
+	pandn	%xmm5,%xmm3						# then negateres gets the values as shown below
+	movdqa	  %xmm3,p_negateres(%rsp)	# save negateres
+
+#  /* p_negateres now means the following.
+#     7FC00000 means x<0, y not an integer, return NaN.
+#     80000000 means x<0, y is odd integer, so set the sign bit.
+##     0 means even integer, and/or x>=0.
+#  */
+
+# **** Here starts the main calculations  ****
+# The algorithm used is x**y = exp(y*log(x))
+#  Extra precision is required in intermediate steps to meet the 1ulp requirement
+#
+# log(x) calculation
+	call		__vrd4_log@PLT		# get the double precision log value
+						# for all four x's
+# y* logx
+	cvtps2pd   p_y(%rsp),%xmm2	#convert the two packed single y's to double
+
+#  /* just multiply by y */
+	mulpd	%xmm2,%xmm0
+	mulpd	%xmm2,%xmm1
+
+#  /* The following code computes r = exp(w) */
+	call		__vrd4_exp@PLT		# get the double exp value
+						# for all four y*log(x)'s
+        mov             p_xptr(%rsp),%rsi       # get x_array pointer
+
+#
+# convert all four results to double
+	cvtpd2ps	%xmm0,%xmm0
+	cvtpd2ps	%xmm1,%xmm1
+	movlhps		%xmm1,%xmm0
+
+# perform special case and error checking on input values
+
+# special case checking is done first in the scalar version since
+# it allows for early fast returns.  But for vectors, we consider them
+# to be rare, so early returns are not necessary.  So we first compute
+# the x**y values, and then check for special cases.
+
+# we do some of the checking in reverse order of the scalar version.
+# apply the negate result flags
+	orps	p_negateres(%rsp),%xmm0	# get negateres
+
+## if y is infinite or so large that the result would overflow or underflow
+	mov		p_y(%rsp),%edx			# get y
+	and 	$0x07fffffff,%edx					# develop ay
+#	mov		$0x04f000000,%eax
+	cmp		$0x04f000000,%edx
+	ja		.Ly_large
+.Lrnsx3:
+
+## if x is infinite
+	movdqa	p_ax(%rsp),%xmm4
+	cmpps	$0,.L__mask_inf(%rip),%xmm4	# equal to infinity, ffs if so.
+	movmskps %xmm4,%edx
+	test	$0x0f,%edx
+	jnz		.Lx_infinite
+.Lrnsx1:
+## if x is zero
+	xorps	%xmm4,%xmm4
+	cmpps	$0,p_ax(%rsp),%xmm4	# equal to zero, ffs if so.
+	movmskps %xmm4,%edx
+	test	$0x0f,%edx
+	jnz		.Lx_zero
+.Lrnsx2:
+## if y is NAN
+	movss	p_y(%rsp),%xmm4			# get y
+	ucomiss	%xmm4,%xmm4						# comparing y to itself should
+											# be true, unless y is a NaN. parity flag if NaN.
+	jp		.Ly_NaN
+.Lrnsx4:
+## if x is NAN
+	movdqa	p_ax(%rsp),%xmm4			# get x
+	cmpps	$4,%xmm4,%xmm4						# a compare not equal  of x to itself should
+											# be false, unless x is a NaN. ff's if NaN.
+	movmskps %xmm4,%ecx
+	test	$0x0f,%ecx
+	jnz		.Lx_NaN
+.Lrnsx5:
+
+## if x == +1, return +1 for all x
+	movdqa	.L__float_one(%rip),%xmm3	# one
+	mov		p_xptr(%rsp),%rdx		# get pointer to x
+	movdqa	%xmm3,%xmm2
+	movdqu	(%rdx), %xmm5
+	cmpps	$4,%xmm5,%xmm2		# not equal to +1.0?, ffs if not equal.
+	andps	%xmm2,%xmm0						# keep the others
+	andnps	%xmm3,%xmm2						# mask for ones
+	orps	%xmm2,%xmm0
+
+.L__vsa_bottom:
+
+# update the x and y pointers
+	add		$16,%rsi
+	mov		%rsi,p_xptr(%rsp)	# save x_array pointer
+# store the result _m128d
+	mov		p_zptr(%rsp),%rdi	# get z_array pointer
+	movups	%xmm0,(%rdi)
+#	prefetchw	QWORD PTR [rdi+64]
+	prefetch	64(%rdi)
+	add		$16,%rdi
+	mov		%rdi,p_zptr(%rsp)	# save z_array pointer
+
+
+	mov		p_iter(%rsp),%rax	# get number of iterations
+	sub		$1,%rax
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	jnz		.L__vsa_top
+
+
+# see if we need to do any extras
+	mov		p_nv(%rsp),%rax	# get number of values
+	test	%rax,%rax
+	jnz		.L__vsa_cleanup
+
+.L__final_check:
+
+	mov		save_rbx(%rsp),%rbx		# restore rbx
+	add		$stack_size,%rsp
+	ret
+
+	.align 16
+# we jump here when we have an odd number of calls to make at the
+# end
+.L__vsa_cleanup:
+        mov             p_nv(%rsp),%rax      # get number of values
+
+	mov		p_xptr(%rsp),%rsi
+	mov		p_y(%rsp),%r8d						# r8 is uy
+
+# fill in a m128 with zeroes and the extra values and then make a recursive call.
+	xorps		%xmm0,%xmm0
+	movaps	  %xmm0,p2_temp(%rsp)
+	movaps	  %xmm0,p2_temp+16(%rsp)
+
+	mov		(%rsi),%ecx			# we know there's at least one
+	mov	 	%ecx,p2_temp(%rsp)
+	mov	 	%r8d,p2_temp+16(%rsp)
+	cmp		$2,%rax
+	jl		.L__vsacg
+
+	mov		4(%rsi),%ecx			# do the second value
+	mov	 	%ecx,p2_temp+4(%rsp)
+	mov	 	%r8d,p2_temp+20(%rsp)
+	cmp		$3,%rax
+	jl		.L__vsacg
+
+	mov		8(%rsi),%ecx			# do the third value
+	mov	 	%ecx,p2_temp+8(%rsp)
+	mov	 	%r8d,p2_temp+24(%rsp)
+
+.L__vsacg:
+	mov		$4,%rdi			# parameter for N
+	lea		p2_temp(%rsp),%rsi	# &x parameter
+	movaps	p2_temp+16(%rsp),%xmm0		# y parameter
+	lea		p2_temp1(%rsp),%rdx	# &z parameter
+	call	vrsa_powxf@PLT			# call recursively to compute four values
+
+# now copy the results to the destination array
+	mov		p_zptr(%rsp),%rdi
+	mov		p_nv(%rsp),%rax		# get number of values
+	mov	 	p2_temp1(%rsp),%ecx
+	mov		%ecx,(%rdi)			# we know there's at least one
+	cmp		$2,%rax
+	jl		.L__vsacgf
+
+	mov	 	p2_temp1+4(%rsp),%ecx
+	mov		%ecx,4(%rdi)			# do the second value
+	cmp		$3,%rax
+	jl		.L__vsacgf
+
+	mov	 	p2_temp1+8(%rsp),%ecx
+	mov		%ecx,8(%rdi)			# do the third value
+
+.L__vsacgf:
+	jmp		.L__final_check
+
+
+	.align 16
+.Ly_zero:
+## if |y| == 0	then return 1
+	mov		$0x03f800000,%ecx	# one
+# fill all results with a one
+	mov		p_zptr(%rsp),%r9	# &z parameter
+	mov		p_nv(%rsp),%rax	# get number of values
+.L__yzt:
+	mov		%ecx,(%r9)			# store a 1
+	add		$4,%r9
+	sub		$1,%rax
+	test	%rax,%rax
+	jnz		.L__yzt
+	jmp		.L__final_check
+#       y is a NaN.
+.Ly_NaN:
+	mov		p_y(%rsp),%r8d
+	or		$0x000400000,%r8d	# convert to QNaNs
+	movd	%r8d,%xmm0			# propagate to all results
+	shufps	$0,%xmm0,%xmm0
+	jmp	   	.Lrnsx4
+
+#       x is a NaN.
+.Lx_NaN:
+	mov		p_xptr(%rsp),%rcx	# get pointer to x
+	movdqu	(%rcx),%xmm4			# get x
+	movdqa	%xmm4,%xmm3
+	movdqa	%xmm4,%xmm5
+	movdqa	.L__mask_sigbit(%rip),%xmm2	# get the signalling bits
+	cmpps	$0,%xmm4,%xmm4		# a compare equal  of x to itself should
+											# be true, unless x is a NaN. 0's if NaN.
+	cmpps	$4,%xmm3,%xmm3		# compare not equal, ff's if NaN.
+	andps	%xmm4,%xmm0		# keep the other results
+	andps	%xmm3,%xmm2		# get just the right signalling bits
+	andps	%xmm5,%xmm3		# mask for the NaNs
+	orps	%xmm2,%xmm3		# convert to QNaNs
+	orps	%xmm3,%xmm0		# combine
+	jmp	   	.Lrnsx5
+
+#       y is infinite or so large that the result would
+#         overflow or underflow.
+.Ly_large:
+	movdqa	  %xmm0,p_temp(%rsp)
+
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		(%rcx),%eax
+	mov		p_y(%rsp),%ebx
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special6				# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp(%rsp)
+
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		4(%rcx),%eax
+	mov		p_y(%rsp),%ebx
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special6				# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+4(%rsp)
+
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		8(%rcx),%eax
+	mov		p_y(%rsp),%ebx
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special6				# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+8(%rsp)
+
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		12(%rcx),%eax
+	mov		p_y(%rsp),%ebx
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special6				# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+12(%rsp)
+
+	movdqa	p_temp(%rsp),%xmm0
+	jmp 	.Lrnsx3
+
+# a subroutine to treat an individual x,y pair when y is large or infinity
+# assumes x in .Ly(%rip),%eax in ebx.
+# returns result in eax
+.Lnp_special6:
+# handle |x|==1 cases first
+	mov		$0x07FFFFFFF,%r8d
+	and		%eax,%r8d
+	cmp		$0x03f800000,%r8d	  # jump if |x| !=1
+	jnz		.Lnps6
+	mov		$0x03f800000,%eax	  # return 1 for all |x|==1
+	jmp 	.Lnpx64
+
+# cases where  |x| !=1
+.Lnps6:
+	mov		$0x07f800000,%ecx
+	xor		%eax,%eax	  # assume 0 return
+	test	$0x080000000,%ebx
+	jnz		.Lnps62		  # jump if y negative
+# y = +inf
+	cmp		$0x03f800000,%r8d
+	cmovg	%ecx,%eax		  # return inf if |x| < 1
+	jmp 	.Lnpx64
+.Lnps62:
+# y = -inf
+	cmp		$0x03f800000,%r8d
+	cmovl	%ecx,%eax		  # return inf if |x| < 1
+	jmp 	.Lnpx64
+
+.Lnpx64:
+	ret
+
+# handle cases where x is +/- infinity.  edx is the mask
+	.align 16
+.Lx_infinite:
+	movdqa	  %xmm0,p_temp(%rsp)
+
+	test	$1,%edx
+	jz		.Lxinfa
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		(%rcx),%eax
+	mov		p_y(%rsp),%ebx
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x1			# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp(%rsp)
+.Lxinfa:
+	test	$2,%edx
+	jz		.Lxinfb
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		p_y(%rsp),%ebx
+	mov		4(%rcx),%eax
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x1			# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+4(%rsp)
+.Lxinfb:
+	test	$4,%edx
+	jz		.Lxinfc
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		p_y(%rsp),%ebx
+	mov		8(%rcx),%eax
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x1			# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+8(%rsp)
+.Lxinfc:
+	test	$8,%edx
+	jz		.Lxinfd
+	mov		p_xptr(%rsp),%rcx		# get pointer to x
+	mov		p_y(%rsp),%ebx
+	mov		12(%rcx),%eax
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x1			# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+12(%rsp)
+.Lxinfd:
+	movdqa	p_temp(%rsp),%xmm0
+	jmp 	.Lrnsx1
+
+# a subroutine to treat an individual x,y pair when x is +/-infinity
+# assumes x in .Ly(%rip),%eax in ebx, inty in ecx.
+# returns result in eax
+.Lnp_special_x1:			# x is infinite
+	test	$0x080000000,%eax	# is x positive
+	jnz		.Lnsx11		# jump if not
+	test	$0x080000000,%ebx	# is y positive
+	jz		.Lnsx13		# just return if so
+	xor		%eax,%eax	# else return 0
+	jmp 	.Lnsx13
+
+.Lnsx11:
+	cmp		$1,%ecx		# if inty ==1
+	jnz		.Lnsx12		# jump if not
+	test	$0x080000000,%ebx	# is y positive
+	jz		.Lnsx13		# just return if so
+	mov		$0x080000000,%eax	# else return -0
+	jmp 	.Lnsx13
+.Lnsx12:				# inty <>1
+	and		$0x07FFFFFFF,%eax	# return -x (|x|)  if y<0
+	test	$0x080000000,%ebx	# is y positive
+	jz		.Lnsx13		#
+	xor		%eax,%eax	# return 0  if y >=0
+.Lnsx13:
+	ret
+
+
+# handle cases where x is +/- zero.  edx is the mask of x,y pairs with |x|=0
+	.align 16
+.Lx_zero:
+	movdqa	  %xmm0,p_temp(%rsp)
+
+	test	$1,%edx
+	jz		.Lxzera
+	mov		p_xptr(%rsp),%rcx	# get pointer to x
+	mov		p_y(%rsp),%ebx
+	mov		(%rcx),%eax
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x2			# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp(%rsp)
+.Lxzera:
+	test	$2,%edx
+	jz		.Lxzerb
+	mov		p_xptr(%rsp),%rcx	# get pointer to x
+	mov		p_y(%rsp),%ebx
+	mov		4(%rcx),%eax
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x2			# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+4(%rsp)
+.Lxzerb:
+	test	$4,%edx
+	jz		.Lxzerc
+	mov		p_xptr(%rsp),%rcx	# get pointer to x
+	mov		p_y(%rsp),%ebx
+	mov		8(%rcx),%eax
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x2			# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+8(%rsp)
+.Lxzerc:
+	test	$8,%edx
+	jz		.Lxzerd
+	mov		p_xptr(%rsp),%rcx	# get pointer to x
+	mov		p_y(%rsp),%ebx
+	mov		12(%rcx),%eax
+	mov		p_inty(%rsp),%ecx
+	sub		$8,%rsp
+	call	.Lnp_special_x2			# call the handler for one value
+	add		$8,%rsp
+	mov		  %eax,p_temp+12(%rsp)
+.Lxzerd:
+	movdqa	p_temp(%rsp),%xmm0
+	jmp 	.Lrnsx2
+
+# a subroutine to treat an individual x,y pair when x is +/-0
+# assumes x in .Ly(%rip),%eax in ebx, inty in ecx.
+# returns result in eax
+	.align 16
+.Lnp_special_x2:
+	cmp		$1,%ecx			# if inty ==1
+	jz		.Lnsx21			# jump if so
+# handle cases of x=+/-0, y not integer
+	xor		%eax,%eax
+	mov		$0x07f800000,%ecx
+	test	$0x080000000,%ebx		# is ypos
+	cmovnz	%ecx,%eax
+	jmp		.Lnsx23
+# y is an integer
+.Lnsx21:
+	xor		%r8d,%r8d
+	mov		$0x07f800000,%ecx
+	test	$0x080000000,%ebx		# is ypos
+	cmovnz	%ecx,%r8d			# set to infinity if not
+	and		$0x080000000,%eax	# pickup the sign of x
+	or		%r8d,%eax		# and include it in the result
+.Lnsx23:
+	ret
+
+        .data
+        .align 64
+
+.L__mask_sign:		.quad 0x08000000080000000	# a sign bit mask
+			.quad 0x08000000080000000
+
+.L__mask_nsign:		.quad 0x07FFFFFFF7FFFFFFF	# a not sign bit mask
+			.quad 0x07FFFFFFF7FFFFFFF
+
+# used by inty
+.L__mask_127:		.quad 0x00000007F0000007F	# EXPBIAS_SP32
+			.quad 0x00000007F0000007F
+
+.L__mask_mant:		.quad 0x0007FFFFF007FFFFF	# mantissa bit mask
+			.quad 0x0007FFFFF007FFFFF
+
+.L__mask_1:		.quad 0x00000000100000001	# 1
+			.quad 0x00000000100000001
+
+.L__mask_2:		.quad 0x00000000200000002	# 2
+			.quad 0x00000000200000002
+
+.L__mask_24:		.quad 0x00000001800000018	# 24
+			.quad 0x00000001800000018
+
+.L__mask_23:		.quad 0x00000001700000017	# 23
+			.quad 0x00000001700000017
+
+# used by special case checking
+
+.L__float_one:		.quad 0x03f8000003f800000	# one
+			.quad 0x03f8000003f800000
+
+.L__mask_inf:		.quad 0x07f8000007F800000	# inifinity
+			.quad 0x07f8000007F800000
+
+.L__mask_ninf:		.quad 0x0ff800000fF800000	# -inifinity
+			.quad 0x0ff800000fF800000
+
+.L__mask_NaN:		.quad 0x07fC000007FC00000	# NaN
+			.quad 0x07fC000007FC00000
+
+.L__mask_sigbit:	.quad 0x00040000000400000	# QNaN bit
+			.quad 0x00040000000400000
+
+.L__mask_impbit:	.quad 0x00080000000800000	# implicit bit
+			.quad 0x00080000000800000
+
+.L__mask_ly:		.quad 0x04f0000004f000000	# large y
+			.quad 0x04f0000004f000000
+
+
+
diff --git a/src/gas/vrsasincosf.S b/src/gas/vrsasincosf.S
new file mode 100644
index 0000000..2bb70bf
--- /dev/null
+++ b/src/gas/vrsasincosf.S
@@ -0,0 +1,2008 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrsasincosf.s
+#
+# A vector implementation of the sincos libm function.
+#
+# Prototype:
+#
+#    __vrsa_sincosf(int n, float* x, float* ys, float* yc);
+#
+# Computes Sine and Cosine of x for an array of input values.
+# Places the Sine results into the supplied ys array and the Cosine results into the supplied yc array.
+# Does not perform error checking.
+# Denormal inputs may produce unexpected results.
+# This routine computes 4 single precision Sine Cosine values at a time.
+# The four values are passed as packed single in xmm0.
+# The four Sine results are returned as packed singles in the supplied ys array.
+# The four Cosine results are returned as packed singles in the supplied yc array.
+# Note that this represents a non-standard ABI usage, as no ABI
+# ( and indeed C) currently allows returning 2 values for a function.
+# It is expected that some compilers may be able to take advantage of this
+# interface when implementing vectorized loops.  Using the array implementation
+# of the routine requires putting the inputs into memory, and retrieving
+# the results from memory.  This routine eliminates the need for this
+# overhead if the data does not already reside in memory.
+
+# Author: Harsha Jagasia
+# Email:  harsha.jagasia@amd.com
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.data
+.align 64
+.L__real_7fffffffffffffff: .quad 0x07fffffffffffffff	#Sign bit zero
+			.quad 0x07fffffffffffffff
+.L__real_3ff0000000000000: .quad 0x03ff0000000000000	# 1.0
+			.quad 0x03ff0000000000000
+.L__real_v2p__27:		.quad 0x03e40000000000000	# 2p-27
+			.quad 0x03e40000000000000
+.L__real_3fe0000000000000: .quad 0x03fe0000000000000	# 0.5
+			.quad 0x03fe0000000000000
+.L__real_3fc5555555555555: .quad 0x03fc5555555555555	# 0.166666666666
+			.quad 0x03fc5555555555555
+.L__real_3fe45f306dc9c883: .quad 0x03fe45f306dc9c883	# twobypi
+			.quad 0x03fe45f306dc9c883
+.L__real_3ff921fb54400000: .quad 0x03ff921fb54400000	# piby2_1
+			.quad 0x03ff921fb54400000
+.L__real_3dd0b4611a626331: .quad 0x03dd0b4611a626331	# piby2_1tail
+			.quad 0x03dd0b4611a626331
+.L__real_3dd0b4611a600000: .quad 0x03dd0b4611a600000	# piby2_2
+			.quad 0x03dd0b4611a600000
+.L__real_3ba3198a2e037073: .quad 0x03ba3198a2e037073	# piby2_2tail
+			.quad 0x03ba3198a2e037073
+.L__real_fffffffff8000000: .quad 0x0fffffffff8000000	# mask for stripping head and tail
+			.quad 0x0fffffffff8000000
+.L__real_8000000000000000:	.quad 0x08000000000000000	# -0  or signbit
+			.quad 0x08000000000000000
+.L__reald_one_one:		.quad 0x00000000100000001	#
+			.quad 0
+.L__reald_two_two:		.quad 0x00000000200000002	#
+			.quad 0
+.L__reald_one_zero:	.quad 0x00000000100000000	# sin_cos_filter
+			.quad 0
+.L__reald_zero_one:	.quad 0x00000000000000001	#
+			.quad 0
+.L__reald_two_zero:	.quad 0x00000000200000000	#
+			.quad 0
+.L__realq_one_one:		.quad 0x00000000000000001	#
+			.quad 0x00000000000000001	#
+.L__realq_two_two:		.quad 0x00000000000000002	#
+			.quad 0x00000000000000002	#
+.L__real_1_x_mask:		.quad 0x0ffffffffffffffff	#
+			.quad 0x03ff0000000000000	#
+.L__real_zero:		.quad 0x00000000000000000	#
+			.quad 0x00000000000000000	#
+.L__real_one:		.quad 0x00000000000000001	#
+			.quad 0x00000000000000001	#
+
+.Lcosarray:
+	.quad	0x03FA5555555502F31		#  0.0416667			c1
+	.quad	0x03FA5555555502F31
+	.quad	0x0BF56C16BF55699D7		# -0.00138889			c2
+	.quad	0x0BF56C16BF55699D7
+	.quad	0x03EFA015C50A93B49		#  2.48016e-005			c3
+	.quad	0x03EFA015C50A93B49
+	.quad	0x0BE92524743CC46B8		# -2.75573e-007			c4
+	.quad	0x0BE92524743CC46B8
+
+.Lsinarray:
+	.quad	0x0BFC555555545E87D		# -0.166667	   		s1
+	.quad	0x0BFC555555545E87D
+	.quad	0x03F811110DF01232D		# 0.00833333	   		s2
+	.quad	0x03F811110DF01232D
+	.quad	0x0BF2A013A88A37196		# -0.000198413			s3
+	.quad	0x0BF2A013A88A37196
+	.quad	0x03EC6DBE4AD1572D5		# 2.75573e-006			s4
+	.quad	0x03EC6DBE4AD1572D5
+
+.Lsincosarray:
+	.quad	0x0BFC555555545E87D		# -0.166667	   		s1
+	.quad	0x03FA5555555502F31		# 0.0416667		   	c1
+	.quad	0x03F811110DF01232D		# 0.00833333	   		s2
+	.quad	0x0BF56C16BF55699D7
+	.quad	0x0BF2A013A88A37196		# -0.000198413			s3
+	.quad	0x03EFA015C50A93B49
+	.quad	0x03EC6DBE4AD1572D5		# 2.75573e-006			s4
+	.quad	0x0BE92524743CC46B8
+
+.Lcossinarray:
+	.quad	0x03FA5555555502F31		# 0.0416667		   	c1
+	.quad	0x0BFC555555545E87D		# -0.166667	   		s1
+	.quad	0x0BF56C16BF55699D7		#				c2
+	.quad	0x03F811110DF01232D
+	.quad	0x03EFA015C50A93B49		#				c3
+	.quad	0x0BF2A013A88A37196
+	.quad	0x0BE92524743CC46B8		#				c4
+	.quad	0x03EC6DBE4AD1572D5
+
+.align 8
+	.Levensin_oddcos_tbl:
+
+		.quad	.Lsinsin_sinsin_piby4		# 0		*	; Done
+		.quad	.Lsinsin_sincos_piby4		# 1		+	; Done
+		.quad	.Lsinsin_cossin_piby4		# 2			; Done
+		.quad	.Lsinsin_coscos_piby4		# 3		+	; Done
+
+		.quad	.Lsincos_sinsin_piby4		# 4			; Done
+		.quad	.Lsincos_sincos_piby4		# 5		*	; Done
+		.quad	.Lsincos_cossin_piby4		# 6			; Done
+		.quad	.Lsincos_coscos_piby4		# 7			; Done
+
+		.quad	.Lcossin_sinsin_piby4		# 8			; Done
+		.quad	.Lcossin_sincos_piby4		# 9			; TBD
+		.quad	.Lcossin_cossin_piby4		# 10		*	; Done
+		.quad	.Lcossin_coscos_piby4		# 11			; Done
+
+		.quad	.Lcoscos_sinsin_piby4		# 12			; Done
+		.quad	.Lcoscos_sincos_piby4		# 13		+	; Done
+		.quad	.Lcoscos_cossin_piby4		# 14			; Done
+		.quad	.Lcoscos_coscos_piby4		# 15		*	; Done
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+        .weak vrsa_sincosf_
+        .set vrsa_sincosf_,__vrsa_sincosf__
+        .weak vrsa_sincosf__
+        .set vrsa_sincosf__,__vrsa_sincosf__
+
+    .text
+    .align 16
+    .p2align 4,,15
+
+#FORTRAN subroutine implementation of array sincos
+#VRSA_SINCOSF(N,X,Y,Z)
+#C equivalent*/
+#void vrsa_sincosf__(int * n, double *x, double *y, double *z)
+#{
+#       vrsa_sincosf(*n,x,y,z);
+#}
+
+.globl __vrsa_sincosf__
+    .type   __vrsa_sincosf__,@function
+__vrsa_sincosf__:
+    mov         (%rdi),%edi
+
+    .align 16
+    .p2align 4,,15
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# define local variable storage offsets
+.equ	p_temp,0		# temporary for get/put bits operation
+.equ	p_temp1,0x10		# temporary for get/put bits operation
+
+.equ	save_xmm6,0x20		# temporary for get/put bits operation
+.equ	save_xmm7,0x30		# temporary for get/put bits operation
+.equ	save_xmm8,0x40		# temporary for get/put bits operation
+.equ	save_xmm9,0x50		# temporary for get/put bits operation
+.equ	save_xmm0,0x60		# temporary for get/put bits operation
+.equ	save_xmm11,0x70		# temporary for get/put bits operation
+.equ	save_xmm12,0x80		# temporary for get/put bits operation
+.equ	save_xmm13,0x90		# temporary for get/put bits operation
+.equ	save_xmm14,0x0A0		# temporary for get/put bits operation
+.equ	save_xmm15,0x0B0		# temporary for get/put bits operation
+
+.equ	r,0x0C0			# pointer to r for remainder_piby2
+.equ	rr,0x0D0		# pointer to r for remainder_piby2
+.equ	region,0x0E0		# pointer to r for remainder_piby2
+
+.equ	r1,0x0F0		# pointer to r for remainder_piby2
+.equ	rr1,0x0100		# pointer to r for remainder_piby2
+.equ	region1,0x0110		# pointer to r for remainder_piby2
+
+.equ	p_temp2,0x0120		# temporary for get/put bits operation
+.equ	p_temp3,0x0130		# temporary for get/put bits operation
+
+.equ	p_temp4,0x0140		# temporary for get/put bits operation
+.equ	p_temp5,0x0150		# temporary for get/put bits operation
+
+.equ	p_original,0x0160		# original x
+.equ	p_mask,0x0170		# original x
+.equ	p_sign_sin,0x0180		# original x
+
+.equ	p_original1,0x0190		# original x
+.equ	p_mask1,0x01A0		# original x
+.equ	p_sign1_sin,0x01B0		# original x
+
+
+.equ	save_r12,0x01C0		# temporary for get/put bits operation
+.equ	save_r13,0x01D0		# temporary for get/put bits operation
+
+.equ	p_sin,0x01E0		# sin
+.equ	p_cos,0x01F0		# cos
+
+.equ	save_rdi,0x0200		# temporary for get/put bits operation
+.equ	save_rsi,0x0210		# temporary for get/put bits operation
+
+.equ	p_sign_cos,0x0220		# Sign of lower cos term
+.equ	p_sign1_cos,0x0230		# Sign of upper cos term
+
+.equ	save_xa,0x0240		#qword ; leave space for 4 args*****
+.equ	save_ysa,0x0250		#qword ; leave space for 4 args*****
+.equ	save_yca,0x0260		#qword ; leave space for 4 args*****
+
+.equ	save_nv,0x0270		#qword
+.equ	p_iter,0x0280		#qword	storage for number of loop iterations
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.globl vrsa_sincosf
+    .type   vrsa_sincosf,@function
+vrsa_sincosf:
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# parameters are passed in by Linux as:
+# rcx - int n
+# rdx - double *x
+# r8  - double *y
+
+	sub		$0x0298,%rsp
+	mov		%r12,save_r12(%rsp)	# save r12
+	mov		%r13,save_r13(%rsp)	# save r13
+
+
+
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#START PROCESS INPUT
+# save the arguments
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+	mov		%rdx,save_ysa(%rsp)	# save ysin_array pointer
+	mov		%rcx,save_yca(%rsp)	# save ycos_array pointer
+#ifdef INTEGER64
+        mov             %rdi,%rax
+#else
+        mov             %edi,%eax
+        mov             %rax,%rdi
+#endif
+	mov		%rdi,save_nv(%rsp)	# save number of values
+# see if too few values to call the main loop
+	shr		$2,%rax				# get number of iterations
+	jz		.L__vrsa_cleanup			# jump if only single calls
+# prepare the iteration counts
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	shl		$2,%rax
+	sub		%rax,%rdi		# compute number of extra single calls
+	mov		%rdi,save_nv(%rsp)	# save number of left over values
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#START LOOP
+.align 16
+.L__vrsa_top:
+# build the input _m128d
+#	movapd	.L__real_7fffffffffffffff,%xmm2	#
+#	mov	.L__real_7fffffffffffffff,%rdx	#
+
+	mov		save_xa(%rsp),%rsi	# get x_array pointer
+	movlps	(%rsi),%xmm0
+	movhps	8(%rsi),%xmm0
+
+	prefetch	32(%rsi)
+	add		$16,%rsi
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+
+
+
+
+
+
+
+
+
+
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#STARTMAIN
+
+	movhlps		%xmm0,%xmm8
+	cvtps2pd	%xmm0,%xmm10			# convert input to double.
+	cvtps2pd	%xmm8,%xmm1			# convert input to double.
+
+movdqa	%xmm10,%xmm6
+movdqa	%xmm1,%xmm7
+movapd	.L__real_7fffffffffffffff(%rip),%xmm2
+
+andpd 	%xmm2,%xmm10				#Unsign
+andpd 	%xmm2,%xmm1				#Unsign
+
+mov	%rdi, p_sin(%rsp)			# save address for sin return
+mov	%rsi,  p_cos(%rsp)			# save address for cos return
+
+movd	%xmm10,%rax				#rax is lower arg
+movhpd	%xmm10, p_temp+8(%rsp)			#
+mov    	p_temp+8(%rsp),%rcx			#rcx = upper arg
+
+movd	%xmm1,%r8				#r8 is lower arg
+movhpd	%xmm1, p_temp1+8(%rsp)			#
+mov    	p_temp1+8(%rsp),%r9			#r9 = upper arg
+
+movdqa	%xmm10,%xmm12
+movdqa	%xmm1,%xmm13
+
+pcmpgtd		%xmm6,%xmm12
+pcmpgtd		%xmm7,%xmm13
+movdqa		%xmm12,%xmm6
+movdqa		%xmm13,%xmm7
+psrldq		$4,%xmm12
+psrldq		$4,%xmm13
+psrldq		$8,%xmm6
+psrldq		$8,%xmm7
+
+mov 	$0x3FE921FB54442D18,%rdx			#piby4	+
+mov	$0x411E848000000000,%r10			#5e5	+
+movapd	.L__real_3fe0000000000000(%rip),%xmm4		#0.5 for later use +
+
+por	%xmm6,%xmm12
+por	%xmm7,%xmm13
+
+movd	%xmm12,%r12				#Move Sign to gpr **
+movd	%xmm13,%r13				#Move Sign to gpr **
+
+movapd	%xmm10,%xmm2				#x0
+movapd	%xmm1,%xmm3				#x1
+movapd	%xmm10,%xmm6				#x0
+movapd	%xmm1,%xmm7				#x1
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm2 = x, xmm4 =0.5/t, xmm6 =x
+# xmm3 = x, xmm5 =0.5/t, xmm7 =x
+.align 16
+.Leither_or_both_arg_gt_than_piby4:
+	cmp	%r10,%rax
+	jae	.Lfirst_or_next3_arg_gt_5e5
+
+	cmp	%r10,%rcx
+	jae	.Lsecond_or_next2_arg_gt_5e5
+
+	cmp	%r10,%r8
+	jae	.Lthird_or_fourth_arg_gt_5e5
+
+	cmp	%r10,%r9
+	jae	.Lfourth_arg_gt_5e5
+
+
+#      /* Find out what multiple of piby2 */
+#        npi2  = (int)(x * twobypi + 0.5);
+	movapd	.L__real_3fe45f306dc9c883(%rip),%xmm10
+	mulpd	%xmm10,%xmm2						# * twobypi
+	mulpd	%xmm10,%xmm3						# * twobypi
+
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	addpd	%xmm4,%xmm3						# +0.5, npi2
+
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm10		# piby2_1
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm1		# piby2_1
+
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	cvttpd2dq	%xmm3,%xmm5					# convert packed double to packed integers
+
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm9		# piby2_2
+
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+	cvtdq2pd	%xmm5,%xmm3					# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+
+	movd	%xmm4,%r8						# Region
+	movd	%xmm5,%r9						# Region
+
+#DELETE
+#	mov 	.LQWORD,%rdx PTR __reald_one_zero			;compare value for cossin path
+#DELETE
+
+	mov	%r8,%r10
+	mov	%r9,%r11
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm10						# npi2 * piby2_1;
+       mulpd	%xmm3,%xmm1						# npi2 * piby2_1;
+
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+       mulpd	%xmm3,%xmm9						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm10,%xmm6						# rhead  = x - npi2 * piby2_1;
+       subpd	%xmm1,%xmm7						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm10						# t
+       movapd	%xmm7,%xmm1						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm10						# rhead
+       subpd	%xmm9,%xmm1						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm3		# npi2 * piby2_2tail
+
+       subpd	%xmm10,%xmm6						# t-rhead
+       subpd	%xmm1,%xmm7						# t-rhead
+
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       subpd	%xmm7,%xmm9						# - ((t - rhead) - rtail)
+
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       addpd	%xmm3,%xmm9						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm4  = npi2 (int), xmm10 =rhead, xmm8 =rtail, r8 = region, r10 = region, r12 = Sign
+# xmm5  = npi2 (int), xmm1 =rhead, xmm9 =rtail,  r9 = region, r11 = region, r13 = Sign
+
+	and	.L__reald_one_one(%rip),%r8		#odd/even region for cos/sin
+	and	.L__reald_one_one(%rip),%r9		#odd/even region for cos/sin
+
+# NEW
+
+	#ADDED
+	mov	%r10,%rdi				# npi2 in int
+	mov	%r11,%rsi				# npi2 in int
+	#ADDED
+
+	shr	$1,%r10					# 0 and 1 => 0
+	shr	$1,%r11					# 2 and 3 => 1
+
+	mov	%r10,%rax
+	mov	%r11,%rcx
+
+	#ADDED
+	xor	%r10,%rdi				# xor last 2 bits of region for cos
+	xor	%r11,%rsi				# xor last 2 bits of region for cos
+	#ADDED
+
+	not 	%r12					#~(sign)
+	not 	%r13					#~(sign)
+	and	%r12,%r10				#region & ~(sign)
+	and	%r13,%r11				#region & ~(sign)
+
+	not	%rax					#~(region)
+	not	%rcx					#~(region)
+	not	%r12					#~~(sign)
+	not	%r13					#~~(sign)
+	and	%r12,%rax				#~region & ~~(sign)
+	and	%r13,%rcx				#~region & ~~(sign)
+
+	#ADDED
+	and	.L__reald_one_one(%rip),%rdi		# sign for cos
+	and	.L__reald_one_one(%rip),%rsi		# sign for cos
+	#ADDED
+
+	or	%rax,%r10
+	or	%rcx,%r11
+	and	.L__reald_one_one(%rip),%r10		# sign for sin
+	and	.L__reald_one_one(%rip),%r11		# sign for sin
+
+
+
+
+
+
+
+	mov	%r10,%r12
+	mov	%r11,%r13
+
+	#ADDED
+	mov	%rdi,%rax
+	mov	%rsi,%rcx
+	#ADDED
+
+	and	.L__reald_one_zero(%rip),%r12		#mask out the lower sign bit leaving the upper sign bit
+	and	.L__reald_one_zero(%rip),%r13		#mask out the lower sign bit leaving the upper sign bit
+
+	#ADDED
+	and	.L__reald_one_zero(%rip),%rax		#mask out the lower sign bit leaving the upper sign bit
+	and	.L__reald_one_zero(%rip),%rcx		#mask out the lower sign bit leaving the upper sign bit
+	#ADDED
+
+	shl	$63,%r10				#shift lower sign bit left by 63 bits
+	shl	$63,%r11				#shift lower sign bit left by 63 bits
+	shl	$31,%r12				#shift upper sign bit left by 31 bits
+	shl	$31,%r13				#shift upper sign bit left by 31 bits
+
+	#ADDED
+	shl	$63,%rdi				#shift lower sign bit left by 63 bits
+	shl	$63,%rsi				#shift lower sign bit left by 63 bits
+	shl	$31,%rax				#shift upper sign bit left by 31 bits
+	shl	$31,%rcx				#shift upper sign bit left by 31 bits
+	#ADDED
+
+	mov 	 %r10,p_sign_sin(%rsp)		#write out lower sign bit
+	mov 	 %r12,p_sign_sin+8(%rsp)		#write out upper sign bit
+	mov 	 %r11,p_sign1_sin(%rsp)		#write out lower sign bit
+	mov 	 %r13,p_sign1_sin+8(%rsp)	#write out upper sign bit
+
+	mov 	 %rdi,p_sign_cos(%rsp)		#write out lower sign bit
+	mov 	 %rax,p_sign_cos+8(%rsp)		#write out upper sign bit
+	mov 	 %rsi,p_sign1_cos(%rsp)		#write out lower sign bit
+	mov 	 %rcx,p_sign1_cos+8(%rsp)	#write out upper sign bit
+
+# NEW
+
+# GET_BITS_DP64(rhead-rtail, uy);			   		; originally only rhead
+# xmm4  = Sign, xmm10 =rhead, xmm8 =rtail
+# xmm5  = Sign, xmm1 =rhead, xmm9 =rtail
+	movapd	%xmm10,%xmm6						# rhead
+	movapd	%xmm1,%xmm7						# rhead
+
+	subpd	%xmm8,%xmm10						# r = rhead - rtail
+	subpd	%xmm9,%xmm1						# r = rhead - rtail
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm4  = Sign, xmm10 = r, xmm6 =rhead, xmm8 =rtail
+# xmm5  = Sign, xmm1 = r, xmm7 =rhead, xmm9 =rtail
+
+#	subpd	%xmm10,%xmm6				;rr=rhead-r
+#	subpd	%xmm1,%xmm7				;rr=rhead-r
+
+	mov	%r8,%rax
+	mov	%r9,%rcx
+
+	movapd	%xmm10,%xmm2				# move r for r2
+	movapd	%xmm1,%xmm3				# move r for r2
+
+	mulpd	%xmm10,%xmm2				# r2
+	mulpd	%xmm1,%xmm3				# r2
+
+#	subpd	xmm6, xmm8				;rr=(rhead-r) -rtail
+#	subpd	xmm7, xmm9				;rr=(rhead-r) -rtail
+
+	and	.L__reald_zero_one(%rip),%rax		# region for jump table
+	and	.L__reald_zero_one(%rip),%rcx
+	shr	$31,%r8
+	shr	$31,%r9
+	or	%r8,%rax
+	or	%r9,%rcx
+	shl	$2,%rcx
+	or	%rcx,%rax
+
+
+# HARSHA ADDED
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign_sin   = Sign, p_sign_cos = Sign,  xmm10 = r, xmm2 = r2
+# p_sign1_sin  = Sign, p_sign1_cos = Sign, xmm1 = r,  xmm3 = r2
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	%xmm2,%xmm14					# for x3
+	movapd	%xmm3,%xmm15					# for x3
+
+	movapd	%xmm2,%xmm0					# for r
+	movapd	%xmm3,%xmm11					# for r
+
+	movdqa	.Lcosarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lcosarray+0x30(%rip),%xmm5			# c4
+
+	movapd	.Lcosarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lcosarray+0x10(%rip),%xmm9			# c2
+
+	movdqa	.Lsinarray+0x30(%rip),%xmm6			# c4
+	movdqa	.Lsinarray+0x30(%rip),%xmm7			# c4
+
+	movapd	.Lsinarray+0x10(%rip),%xmm12			# c2
+	movapd	.Lsinarray+0x10(%rip),%xmm13			# c2
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm10,%xmm14					# x3
+	mulpd	%xmm1,%xmm15					# x3
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	mulpd	%xmm2,%xmm6					# c2*x2
+	mulpd	%xmm3,%xmm7					# c2*x2
+
+	mulpd	%xmm2,%xmm12					# c4*x2
+	mulpd	%xmm3,%xmm13					# c4*x2
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm0		# -t=r-1.0	;trash r
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0	;trash r
+
+	mulpd	%xmm2,%xmm2					# x4
+	mulpd	%xmm3,%xmm3					# x4
+
+	addpd	.Lcosarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lcosarray+0x20(%rip),%xmm5			# c3+x2c4
+
+	addpd	.Lcosarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lcosarray(%rip),%xmm9			# c1+x2c2
+
+	addpd	.Lsinarray+0x20(%rip),%xmm6			# c3+x2c4
+	addpd	.Lsinarray+0x20(%rip),%xmm7			# c3+x2c4
+
+	addpd	.Lsinarray(%rip),%xmm12			# c1+x2c2
+	addpd	.Lsinarray(%rip),%xmm13			# c1+x2c2
+
+	mulpd	%xmm2,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm3,%xmm5					# x4(c3+x2c4)
+
+	mulpd	%xmm2,%xmm6					# x4(c3+x2c4)
+	mulpd	%xmm3,%xmm7					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zc
+
+	addpd	%xmm12,%xmm6					# zs
+	addpd	%xmm13,%xmm7					# zs
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x4 * zc
+
+	mulpd	%xmm14,%xmm6					# x3 * zs
+	mulpd	%xmm15,%xmm7					# x3 * zs
+
+	subpd   %xmm0,%xmm4					# - (-t)
+	subpd   %xmm11,%xmm5					# - (-t)
+
+	addpd	%xmm10,%xmm6					# +x
+	addpd	%xmm1,%xmm7					# +x
+
+# HARSHA ADDED
+
+	lea	.Levensin_oddcos_tbl(%rip),%rcx
+	jmp	*(%rcx,%rax,8)					#Jmp table for cos/sin calculation based on even/odd region
+
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lfirst_or_next3_arg_gt_5e5:
+# %rcx,,%rax r8, r9
+
+	cmp	%r10,%rcx				#is upper arg >= 5e5
+	jae	.Lboth_arg_gt_5e5
+
+.Llower_arg_gt_5e5:
+# Upper Arg is < 5e5, Lower arg is >= 5e5
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+# Be sure not to use %xmm3,%xmm1 and xmm7
+# Use %xmm8,,%xmm5 xmm0, xmm12
+#	    %xmm11,,%xmm9 xmm13
+
+
+	movlpd	 %xmm10,r(%rsp)		#Save lower fp arg for remainder_piby2 call
+	movhlps	%xmm10,%xmm10			#Needed since we want to work on upper arg
+	movhlps	%xmm2,%xmm2
+	movhlps	%xmm6,%xmm6
+
+# Work on Upper arg
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm4,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm8		# xmm8 = piby2_1
+	cvttsd2si	%xmm2,%ecx				# ecx = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm0		# xmm0 = piby2_2
+	cvtsi2sd	%ecx,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm8					# npi2 * piby2_1
+	subsd	%xmm8,%xmm6					# xmm6 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm12		# xmm12 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm6,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm0					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm0,%xmm6					# xmm6 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm12     					# npi2 * piby2_2tail
+       subsd	%xmm6,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm0					# (rtail-(t-rhead))
+       addsd	%xmm12,%xmm0					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %ecx,region+4(%rsp)			# store upper region
+       movsd	%xmm6,%xmm10
+       subsd	%xmm0,%xmm10					# xmm10 = r=(rhead-rtail)
+       subsd	%xmm10,%xmm6					# rr=rhead-r
+       subsd	%xmm0,%xmm6					# xmm6 = rr=((rhead-r) -rtail)
+       movlpd	 %xmm10,r+8(%rsp)			# store upper r
+       movlpd	 %xmm6,rr+8(%rsp)			# store upper rr
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#Note that volatiles will be trashed by the call
+#We will construct r, rr, region and sign
+
+# Work on Lower arg
+	mov		$0x07ff0000000000000,%r11			# is lower arg nan/inf
+	mov		%r11,%r10
+	and		%rax,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sincosf_lower_naninf
+
+	mov	  %r8,p_temp(%rsp)
+	mov	  %r9,p_temp2(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region(%rsp),%rdx			# lower arg is **NOT** nan/inf
+	lea	 r(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	mov	 r(%rsp),%rdi				#Restore lower fp arg for remainder_piby2 call
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	 p_temp(%rsp),%r8
+	mov	 p_temp2(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+	jmp 	0f
+
+.L__vrs4_sincosf_lower_naninf:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rax
+	mov	 %rax,r(%rsp)				# r = x | 0x0008000000000000
+	mov	 %r10d,region(%rsp)			# region =0
+
+.align 16
+0:
+
+	jmp 	.Lcheck_next2_args
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lboth_arg_gt_5e5:
+#Upper Arg is >= 5e5, Lower arg is >= 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+
+	movhlps %xmm10,%xmm6		#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r11			#is lower arg nan/inf
+	mov		%r11,%r10
+	and		%rax,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sincosf_lower_naninf_of_both_gt_5e5
+
+	mov	  %rcx,p_temp(%rsp)			#Save upper arg
+	mov	  %r8,p_temp2(%rsp)
+	mov	  %r9,p_temp4(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	 r(%rsp),%rsi
+
+# added ins- changed input from xmm10 to xmm0
+	movd	%xmm10,%rdi
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	 p_temp2(%rsp),%r8
+	mov	 p_temp4(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+
+	mov	 p_temp(%rsp),%rcx			#Restore upper arg
+	jmp 	0f
+
+.L__vrs4_sincosf_lower_naninf_of_both_gt_5e5:				#lower arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rax
+	mov	 %rax,r(%rsp)				#r = x | 0x0008000000000000
+	mov	 %r10d,region(%rsp)			#region = 0
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r11			#is upper arg nan/inf
+	mov		%r11,%r10
+	and		%rcx,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sincosf_upper_naninf_of_both_gt_5e5
+
+
+	mov	  %r8,p_temp2(%rsp)
+	mov	  %r9,p_temp4(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region+4(%rsp),%rdx			#upper arg is **NOT** nan/inf
+	lea	 r+8(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	movd	 %xmm6,%rdi				#Restore upper fp arg for remainder_piby2 call
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	 p_temp2(%rsp),%r8
+	mov	 p_temp4(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+
+	jmp 	0f
+
+.L__vrs4_sincosf_upper_naninf_of_both_gt_5e5:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rcx
+	mov	 %rcx,r+8(%rsp)				#r = x | 0x0008000000000000
+	mov	 %r10d,region+4(%rsp)			#region = 0
+
+.align 16
+0:
+	jmp 	.Lcheck_next2_args
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lsecond_or_next2_arg_gt_5e5:
+
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+# Do not use %xmm3,,%xmm1 xmm7
+# Restore xmm4 and %xmm3,,%xmm1 xmm7
+# Can use %xmm0,,%xmm8 xmm12
+#   %xmm9,,%xmm5 xmm11, xmm13
+
+	movhpd	 %xmm10,r+8(%rsp)	#Save upper fp arg for remainder_piby2 call
+
+# Work on Lower arg
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm4,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm8		# xmm3 = piby2_1
+	cvttsd2si	%xmm2,%eax				# ecx = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm0		# xmm1 = piby2_2
+	cvtsi2sd	%eax,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm8					# npi2 * piby2_1
+	subsd	%xmm8,%xmm6					# xmm6 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm12		# xmm7 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm6,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm0					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm0,%xmm6					# xmm6 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm12     					# npi2 * piby2_2tail
+       subsd	%xmm6,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm0					# (rtail-(t-rhead))
+       addsd	%xmm12,%xmm0					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %eax,region(%rsp)			# store upper region
+
+#       movsd	%xmm6,%xmm10
+#       subsd	xmm10,xmm0					; xmm10 = r=(rhead-rtail)
+#       subsd	%xmm10,%xmm6					; rr=rhead-r
+#       subsd	xmm6, xmm0					; xmm6 = rr=((rhead-r) -rtail)
+
+        subsd	%xmm0,%xmm6					# xmm10 = r=(rhead-rtail)
+
+#       movlpd	QWORD PTR r[rsp], xmm10				; store upper r
+#       movlpd	QWORD PTR rr[rsp], xmm6				; store upper rr
+
+        movlpd	 %xmm6,r(%rsp)				# store upper r
+
+
+#Work on Upper arg
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+	mov		$0x07ff0000000000000,%r11			# is upper arg nan/inf
+	mov		%r11,%r10
+	and		%rcx,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sincosf_upper_naninf
+
+	mov	 %r8,p_temp(%rsp)
+	mov	 %r9,p_temp2(%rsp)
+	movapd	 %xmm1,p_temp1(%rsp)
+	movapd	 %xmm3,p_temp3(%rsp)
+	movapd	 %xmm7,p_temp5(%rsp)
+
+	lea	 region+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 r+8(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	mov	 r+8(%rsp),%rdi				#Restore upper fp arg for remainder_piby2 call
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	p_temp(%rsp),%r8
+	mov	p_temp2(%rsp),%r9
+	movapd	p_temp1(%rsp),%xmm1
+	movapd	p_temp3(%rsp),%xmm3
+	movapd	p_temp5(%rsp),%xmm7
+	jmp 	0f
+
+.L__vrs4_sincosf_upper_naninf:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rcx
+	mov	 %rcx,r+8(%rsp)				# r = x | 0x0008000000000000
+	mov	 %r10d,region+4(%rsp)			# region =0
+
+.align 16
+0:
+
+	jmp	.Lcheck_next2_args
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcheck_next2_args:
+
+	mov	$0x411E848000000000,%r10			#5e5	+
+
+	cmp	%r10,%r8
+	jae	.Lfirst_second_done_third_or_fourth_arg_gt_5e5
+
+	cmp	%r10,%r9
+	jae	.Lfirst_second_done_fourth_arg_gt_5e5
+
+
+
+# Work on next two args, both < 5e5
+# %xmm3,,%xmm1 xmm5 = x, xmm4 = 0.5
+
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4			#Restore 0.5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm3						# * twobypi
+	addpd	%xmm4,%xmm3						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm1		# piby2_1
+	cvttpd2dq	%xmm3,%xmm5					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm9		# piby2_2
+	cvtdq2pd	%xmm5,%xmm3					# and back to double.
+
+###
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movlpd	 %xmm5,region1(%rsp)						# Region
+###
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm3,%xmm1						# npi2 * piby2_1;
+
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm3,%xmm9						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm1,%xmm7						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm7,%xmm1						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm9,%xmm1						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm3		# npi2 * piby2_2tail
+
+       subpd	%xmm1,%xmm7						# t-rhead
+       subpd	%xmm7,%xmm9						# - ((t - rhead) - rtail)
+       addpd	%xmm3,%xmm9						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+#       movapd	%xmm1,%xmm7						; rhead
+       subpd	%xmm9,%xmm1						# r = rhead - rtail
+       movapd	 %xmm1,r1(%rsp)
+
+#       subpd	%xmm1,%xmm7						; rr=rhead-r
+#       subpd	xmm7, xmm9						; rr=(rhead-r) -rtail
+#       movapd	OWORD PTR rr1[rsp], xmm7
+
+	jmp	.L__vrs4_sincosf_reconstruct
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lthird_or_fourth_arg_gt_5e5:
+#first two args are < 5e5, third arg >= 5e5, fourth arg >= 5e5 or < 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+# Do not use %xmm3,,%xmm1 xmm7
+# Can use 	%xmm11,,%xmm9 xmm13
+# 	%xmm8,,%xmm5 xmm0, xmm12
+# Restore xmm4
+
+# Work on first two args, both < 5e5
+
+
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# * twobypi
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm10		# piby2_1
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+
+###
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movlpd	 %xmm4,region(%rsp)				# Region
+###
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm10						# npi2 * piby2_1;
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm10,%xmm6						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm10						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm10						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+
+       subpd	%xmm10,%xmm6						# t-rhead
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+#       movapd	%xmm10,%xmm6						; rhead
+       subpd	%xmm8,%xmm10						# r = rhead - rtail
+       movapd	 %xmm10,r(%rsp)
+
+#       subpd	%xmm10,%xmm6						; rr=rhead-r
+#       subpd	xmm6, xmm8						; rr=(rhead-r) -rtail
+#       movapd	OWORD PTR rr[rsp], xmm6
+
+
+# Work on next two args, third arg >= 5e5, fourth arg >= 5e5 or < 5e5
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lfirst_second_done_third_or_fourth_arg_gt_5e5:
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+
+
+	mov	$0x411E848000000000,%r10			#5e5	+
+	cmp	%r10,%r9
+	jae	.Lboth_arg_gt_5e5_higher
+
+
+# Upper Arg is <5e5, Lower arg is >= 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+	movlpd	 %xmm1,r1(%rsp)		#Save lower fp arg for remainder_piby2 call
+	movhlps	%xmm1,%xmm1			#Needed since we want to work on upper arg
+	movhlps	%xmm3,%xmm3
+	movhlps	%xmm7,%xmm7
+
+
+# Work on Upper arg
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4		# Restore 0.5
+
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm3		# x*twobypi
+	addsd	%xmm4,%xmm3					# xmm3 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm2		# xmm2 = piby2_1
+	cvttsd2si	%xmm3,%r9d				# r9d = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm10		# xmm10 = piby2_2
+	cvtsi2sd	%r9d,%xmm3				# xmm3 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm3,%xmm2					# npi2 * piby2_1
+	subsd	%xmm2,%xmm7					# xmm7 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm7,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm3,%xmm10					# xmm10 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm10,%xmm7					# xmm7 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm3,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm7,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm10					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm10					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %r9d,region1+4(%rsp)			# store upper region
+
+
+       subsd	%xmm10,%xmm7					# xmm1 = r=(rhead-rtail)
+
+       movlpd	 %xmm7,r1+8(%rsp)			# store upper r
+
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+
+# Work on Lower arg
+	mov		$0x07ff0000000000000,%r11			# is lower arg nan/inf
+	mov		%r11,%r10
+	and		%r8,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sincosf_lower_naninf_higher
+
+	lea	 region1(%rsp),%rdx			# lower arg is **NOT** nan/inf
+	lea	 r1(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	mov	 r1(%rsp),%rdi				#Restore lower fp arg for remainder_piby2 call
+
+	call	 __remainder_piby2d2f@PLT
+
+	jmp 	0f
+
+.L__vrs4_sincosf_lower_naninf_higher:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r8
+	mov	 %r8,r1(%rsp)				# r = x | 0x0008000000000000
+	mov	 %r10d,region1(%rsp)			# region =0
+
+.align 16
+0:
+	jmp 	.L__vrs4_sincosf_reconstruct
+
+
+
+
+
+
+
+.align 16
+.Lboth_arg_gt_5e5_higher:
+# Upper Arg is >= 5e5, Lower arg is >= 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+
+	movhlps %xmm1,%xmm7		#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r11			#is lower arg nan/inf
+	mov		%r11,%r10
+	and		%r8,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sincosf_lower_naninf_of_both_gt_5e5_higher
+
+	mov	  %r9,p_temp1(%rsp)			#Save upper arg
+	lea	  region1(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	  r1(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	movd	 %xmm1,%rdi
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	 p_temp1(%rsp),%r9			#Restore upper arg
+
+
+	jmp 	0f
+
+.L__vrs4_sincosf_lower_naninf_of_both_gt_5e5_higher:				#lower arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r8
+	mov	 %r8,r1(%rsp)				#r = x | 0x0008000000000000
+	mov	 %r10d,region1(%rsp)			#region = 0
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r11			#is upper arg nan/inf
+	mov		%r11,%r10
+	and		%r9,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sincosf_upper_naninf_of_both_gt_5e5_higher
+
+	lea	 region1+4(%rsp),%rdx			#upper arg is **NOT** nan/inf
+	lea	 r1+8(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	movd	 %xmm7,%rdi			#Restore upper fp arg for remainder_piby2 call
+
+
+	call	 __remainder_piby2d2f@PLT
+
+	jmp 	0f
+
+.L__vrs4_sincosf_upper_naninf_of_both_gt_5e5_higher:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r9
+	mov	 %r9,r1+8(%rsp)				#r = x | 0x0008000000000000
+	mov	 %r10d,region1+4(%rsp)			#region = 0
+
+.align 16
+0:
+
+	jmp 	.L__vrs4_sincosf_reconstruct
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lfourth_arg_gt_5e5:
+#first two args are < 5e5, third arg < 5e5, fourth arg >= 5e5
+#%rcx,,%rax r8, r9
+#%xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+
+# Work on first two args, both < 5e5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# * twobypi
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm10		# piby2_1
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+
+###
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movlpd	 %xmm4,region(%rsp)				# Region
+###
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm10						# npi2 * piby2_1;
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm10,%xmm6						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm10						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm10						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+
+       subpd	%xmm10,%xmm6						# t-rhead
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+#       movapd	%xmm10,%xmm6						; rhead
+       subpd	%xmm8,%xmm10						# r = rhead - rtail
+       movapd	 %xmm10,r(%rsp)
+
+#       subpd	%xmm10,%xmm6						; rr=rhead-r
+#       subpd	xmm6, xmm8						; rr=(rhead-r) -rtail
+#       movapd	OWORD PTR rr[rsp], xmm6
+
+
+# Work on next two args, third arg < 5e5, fourth arg >= 5e5
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lfirst_second_done_fourth_arg_gt_5e5:
+
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+	movhpd	 %xmm1,r1+8(%rsp)	#Save upper fp arg for remainder_piby2 call
+
+
+# Work on Lower arg
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4		# Restore 0.5
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm3		# x*twobypi
+	addsd	%xmm4,%xmm3					# xmm3 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm2		# xmm2 = piby2_1
+	cvttsd2si	%xmm3,%r8d				# r8d = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm10		# xmm10 = piby2_2
+	cvtsi2sd	%r8d,%xmm3				# xmm3 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm3,%xmm2					# npi2 * piby2_1
+	subsd	%xmm2,%xmm7					# xmm7 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm7,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm3,%xmm10					# xmm10 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm10,%xmm7					# xmm7 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm3,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm7,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm10					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm10					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %r8d,region1(%rsp)			# store lower region
+
+#       movsd	%xmm7,%xmm1
+#       subsd	xmm1, xmm10					; xmm10 = r=(rhead-rtail)
+#       subsd	%xmm1,%xmm7					; rr=rhead-r
+#       subsd	xmm7, xmm10					; xmm6 = rr=((rhead-r) -rtail)
+
+        subsd	%xmm10,%xmm7					# xmm10 = r=(rhead-rtail)
+
+#       movlpd	QWORD PTR r1[rsp], xmm1				; store upper r
+#       movlpd	QWORD PTR rr1[rsp], xmm7			; store upper rr
+
+        movlpd	 %xmm7,r1(%rsp)				# store upper r
+
+#Work on Upper arg
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+	mov		$0x07ff0000000000000,%r11			# is upper arg nan/inf
+	mov		%r11,%r10
+	and		%r9,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sincosf_upper_naninf_higher
+
+	lea	 region1+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 r1+8(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	mov	 r1+8(%rsp),%rdi				#Restore upper fp arg for remainder_piby2 call
+
+	call	 __remainder_piby2d2f@PLT
+
+	jmp 	0f
+
+.L__vrs4_sincosf_upper_naninf_higher:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r9
+	mov	 %r9,r1+8(%rsp)				# r = x | 0x0008000000000000
+	mov	 %r10d,region1+4(%rsp)			# region =0
+
+.align 16
+0:
+	jmp	.L__vrs4_sincosf_reconstruct
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrs4_sincosf_reconstruct:
+#Results
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign_sin  = Sign,  ; p_sign_cos   = Sign, xmm10 = r, xmm2 = r2
+# p_sign1_sin  = Sign, ; p_sign1_cos  = Sign, xmm1 = r, xmm3 = r2
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	r(%rsp),%xmm10
+	movapd	r1(%rsp),%xmm1
+
+	mov	region(%rsp),%r8
+	mov	region1(%rsp),%r9
+
+	mov 	%r8,%r10
+	mov 	%r9,%r11
+
+	and	.L__reald_one_one(%rip),%r8		#odd/even region for cos/sin
+	and	.L__reald_one_one(%rip),%r9		#odd/even region for cos/sin
+
+
+# NEW
+
+	#ADDED
+	mov	%r10,%rdi
+	mov	%r11,%rsi
+	#ADDED
+
+	shr	$1,%r10						#~AB+A~B, A is sign and B is upper bit of region
+	shr	$1,%r11						#~AB+A~B, A is sign and B is upper bit of region
+
+	mov	%r10,%rax
+	mov	%r11,%rcx
+
+	#ADDED
+	xor	%r10,%rdi
+	xor	%r11,%rsi
+	#ADDED
+
+	not 	%r12						#ADDED TO CHANGE THE LOGIC
+	not 	%r13						#ADDED TO CHANGE THE LOGIC
+	and	%r12,%r10
+	and	%r13,%r11
+
+	not	%rax
+	not	%rcx
+	not	%r12
+	not	%r13
+	and	%r12,%rax
+	and	%r13,%rcx
+
+	#ADDED
+	and	.L__reald_one_one(%rip),%rdi				#(~AB+A~B)&1
+	and	.L__reald_one_one(%rip),%rsi				#(~AB+A~B)&1
+	#ADDED
+
+	or	%rax,%r10
+	or	%rcx,%r11
+	and	.L__reald_one_one(%rip),%r10				#(~AB+A~B)&1
+	and	.L__reald_one_one(%rip),%r11				#(~AB+A~B)&1
+
+
+
+
+
+
+
+	mov	%r10,%r12
+	mov	%r11,%r13
+
+	#ADDED
+	mov	%rdi,%rax
+	mov	%rsi,%rcx
+	#ADDED
+
+	and	.L__reald_one_zero(%rip),%r12		#mask out the lower sign bit leaving the upper sign bit
+	and	.L__reald_one_zero(%rip),%r13		#mask out the lower sign bit leaving the upper sign bit
+
+	#ADDED
+	and	.L__reald_one_zero(%rip),%rax		#mask out the lower sign bit leaving the upper sign bit
+	and	.L__reald_one_zero(%rip),%rcx		#mask out the lower sign bit leaving the upper sign bit
+	#ADDED
+
+	shl	$63,%r10				#shift lower sign bit left by 63 bits
+	shl	$63,%r11				#shift lower sign bit left by 63 bits
+	shl	$31,%r12				#shift upper sign bit left by 31 bits
+	shl	$31,%r13				#shift upper sign bit left by 31 bits
+
+	#ADDED
+	shl	$63,%rdi				#shift lower sign bit left by 63 bits
+	shl	$63,%rsi				#shift lower sign bit left by 63 bits
+	shl	$31,%rax				#shift upper sign bit left by 31 bits
+	shl	$31,%rcx				#shift upper sign bit left by 31 bits
+	#ADDED
+
+	mov 	 %r10,p_sign_sin(%rsp)		#write out lower sign bit
+	mov 	 %r12,p_sign_sin+8(%rsp)		#write out upper sign bit
+	mov 	 %r11,p_sign1_sin(%rsp)		#write out lower sign bit
+	mov 	 %r13,p_sign1_sin+8(%rsp)	#write out upper sign bit
+
+	mov 	 %rdi,p_sign_cos(%rsp)		#write out lower sign bit
+	mov 	 %rax,p_sign_cos+8(%rsp)		#write out upper sign bit
+	mov 	 %rsi,p_sign1_cos(%rsp)		#write out lower sign bit
+	mov 	 %rcx,p_sign1_cos+8(%rsp)	#write out upper sign bit
+#NEW
+
+
+	mov	%r8,%rax
+	mov	%r9,%rcx
+
+	movapd	%xmm10,%xmm2
+	movapd	%xmm1,%xmm3
+
+	mulpd	%xmm10,%xmm2				# r2
+	mulpd	%xmm1,%xmm3				# r2
+
+	and	.L__reald_zero_one(%rip),%rax
+	and	.L__reald_zero_one(%rip),%rcx
+	shr	$31,%r8
+	shr	$31,%r9
+	or	%r8,%rax
+	or	%r9,%rcx
+	shl	$2,%rcx
+	or	%rcx,%rax
+
+
+# HARSHA ADDED
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign_cos  = Sign, p_sign_sin  = Sign, xmm10 = r, xmm2 = r2
+# p_sign1_cos = Sign, p_sign1_sin = Sign, xmm1 = r,  xmm3 = r2
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	%xmm2,%xmm14					# for x3
+	movapd	%xmm3,%xmm15					# for x3
+
+	movapd	%xmm2,%xmm0					# for r
+	movapd	%xmm3,%xmm11					# for r
+
+	movdqa	.Lcosarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lcosarray+0x30(%rip),%xmm5			# c4
+
+	movapd	.Lcosarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lcosarray+0x10(%rip),%xmm9			# c2
+
+	movdqa	.Lsinarray+0x30(%rip),%xmm6			# c4
+	movdqa	.Lsinarray+0x30(%rip),%xmm7			# c4
+
+	movapd	.Lsinarray+0x10(%rip),%xmm12			# c2
+	movapd	.Lsinarray+0x10(%rip),%xmm13			# c2
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm10,%xmm14					# x3
+	mulpd	%xmm1,%xmm15					# x3
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	mulpd	%xmm2,%xmm6					# c2*x2
+	mulpd	%xmm3,%xmm7					# c2*x2
+
+	mulpd	%xmm2,%xmm12					# c4*x2
+	mulpd	%xmm3,%xmm13					# c4*x2
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm0		# -t=r-1.0	;trash r
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0	;trash r
+
+	mulpd	%xmm2,%xmm2					# x4
+	mulpd	%xmm3,%xmm3					# x4
+
+	addpd	.Lcosarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lcosarray+0x20(%rip),%xmm5			# c3+x2c4
+
+	addpd	.Lcosarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lcosarray(%rip),%xmm9			# c1+x2c2
+
+	addpd	.Lsinarray+0x20(%rip),%xmm6			# c3+x2c4
+	addpd	.Lsinarray+0x20(%rip),%xmm7			# c3+x2c4
+
+	addpd	.Lsinarray(%rip),%xmm12			# c1+x2c2
+	addpd	.Lsinarray(%rip),%xmm13			# c1+x2c2
+
+	mulpd	%xmm2,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm3,%xmm5					# x4(c3+x2c4)
+
+	mulpd	%xmm2,%xmm6					# x4(c3+x2c4)
+	mulpd	%xmm3,%xmm7					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zc
+
+	addpd	%xmm12,%xmm6					# zs
+	addpd	%xmm13,%xmm7					# zs
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x4 * zc
+
+	mulpd	%xmm14,%xmm6					# x3 * zs
+	mulpd	%xmm15,%xmm7					# x3 * zs
+
+	subpd   %xmm0,%xmm4					# - (-t)
+	subpd   %xmm11,%xmm5					# - (-t)
+
+	addpd	%xmm10,%xmm6					# +x
+	addpd	%xmm1,%xmm7					# +x
+
+# HARSHA ADDED
+
+
+	lea	.Levensin_oddcos_tbl(%rip),%rcx
+	jmp	*(%rcx,%rax,8)					#Jmp table for cos/sin calculation based on even/odd region
+
+
+
+
+
+
+
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrsa_sincosf_cleanup:
+
+	movapd	p_sign_cos(%rsp),%xmm10
+	movapd	p_sign1_cos(%rsp),%xmm1
+	xorpd	%xmm4,%xmm10			# Cos term   (+) Sign
+	xorpd	%xmm5,%xmm1			# Cos term   (+) Sign
+
+	cvtpd2ps %xmm10,%xmm0
+	cvtpd2ps %xmm1,%xmm11
+
+	movapd	p_sign_sin(%rsp),%xmm14
+	movapd	p_sign1_sin(%rsp),%xmm15
+	xorpd	%xmm6,%xmm14			# Sin term (+) Sign
+	xorpd	%xmm7,%xmm15			# Sin term (+) Sign
+
+	cvtpd2ps %xmm14,%xmm12
+	cvtpd2ps %xmm15,%xmm13
+
+
+.L__vrsa_bottom1:
+# store the result _m128d
+
+	mov	save_ysa(%rsp),%r8
+	mov	save_yca(%rsp),%r9
+
+	movlps	 %xmm0,  (%r9)			# save the cos
+	movlps	 %xmm12, (%r8)			# save the sin
+	movlps	 %xmm11, 8(%r9)			# save the cos
+	movlps	 %xmm13, 8(%r8)			# save the sin
+
+
+	prefetch	32(%r8)
+	prefetch	32(%r9)
+
+	add		$16,%r8
+	add		$16,%r9
+
+	mov		%r8,save_ysa(%rsp)	# save y_sinarray pointer
+	mov		%r9,save_yca(%rsp)	# save y_cosarray pointer
+
+	mov	p_iter(%rsp),%rax		# get number of iterations
+	sub	$1,%rax
+	mov	%rax,p_iter(%rsp)		# save number of iterations
+	jnz	.L__vrsa_top
+
+# see if we need to do any extras
+	mov	save_nv(%rsp),%rax	# get number of values
+	test	%rax,%rax
+	jnz	.L__vrsa_cleanup
+
+.L__final_check:
+
+	mov	save_r12(%rsp),%r12	# restore r12
+	mov	save_r13(%rsp),%r13	# restore r13
+
+	add	$0x0298,%rsp
+	ret
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# we jump here when we have an odd number of cos calls to make at the end
+# we assume that rdx is pointing at the next x array element, r8 at the next y array element.
+# The number of values left is in save_nv
+
+.align	16
+.L__vrsa_cleanup:
+        mov             save_nv(%rsp),%rax      # get number of values
+        test            %rax,%rax               # are there any values
+        jz              .L__final_check         # exit if not
+
+	mov		save_xa(%rsp),%rsi
+	mov		save_ysa(%rsp),%rdi
+	mov		save_yca(%rsp),%r12
+
+
+# fill in a m128d with zeroes and the extra values and then make a recursive call.
+	xorps		 %xmm0,%xmm0
+	movss		 %xmm0,p_temp+4(%rsp)
+	movlps		 %xmm0,p_temp+8(%rsp)
+
+
+	mov		 (%rsi),%ecx			# we know there's at least one
+	mov	 	 %ecx,p_temp(%rsp)
+	cmp		 $2,%rax
+	jl		 .L__vrsacg
+
+	mov		 4(%rsi),%ecx			# do the second value
+	mov	 	 %ecx,p_temp+4(%rsp)
+	cmp		 $3,%rax
+	jl		 .L__vrsacg
+
+	mov		 8(%rsi),%ecx			# do the third value
+	mov	 	 %ecx,p_temp+8(%rsp)
+
+.L__vrsacg:
+	mov		$4,%rdi				# parameter for N
+	lea		p_temp(%rsp),%rsi		# &x parameter
+	lea		p_temp2(%rsp),%rdx	 	# &ys parameter
+	lea		p_temp3(%rsp),%rcx		# &yc parameter
+	call		vrsa_sincosf@PLT		# call recursively to compute four values
+
+# now copy the results to the destination array
+	mov		save_ysa(%rsp),%rdi
+	mov		save_yca(%rsp),%r12
+	mov		save_nv(%rsp),%rax			# get number of values
+
+	mov	 	p_temp2(%rsp),%ecx
+	mov		%ecx,(%rdi)			# we know there's at least one
+	mov	 	p_temp3(%rsp),%edx
+	mov		%edx,(%r12)			# we know there's at least one
+	cmp		$2,%rax
+	jl		.L__vrsacgf
+
+	mov	 	p_temp2+4(%rsp),%ecx
+	mov		%ecx,4(%rdi)			# do the second value
+	mov	 	p_temp3+4(%rsp),%edx
+	mov		%edx,4(%r12)			# do the second value
+	cmp		$3,%rax
+	jl		.L__vrsacgf
+
+	mov	 	p_temp2+8(%rsp),%ecx
+	mov		%ecx,8(%rdi)			# do the third value
+	mov	 	p_temp3+8(%rsp),%edx
+	mov		%edx,8(%r12)			# do the third value
+
+.L__vrsacgf:
+	jmp		.L__final_check
+
+
+
+
+
+
+
+
+
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;JUMP TABLE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+.align 16
+.Lcoscos_coscos_piby4:
+# Cos in %xmm5,%xmm4
+# Sin in %xmm7,%xmm6
+# Lower and Upper Even
+
+	movapd	%xmm4,%xmm8
+	movapd	%xmm5,%xmm9
+
+	movapd	%xmm6,%xmm4
+	movapd	%xmm7,%xmm5
+
+	movapd	%xmm8,%xmm6
+	movapd	%xmm9,%xmm7
+
+	jmp 	.L__vrsa_sincosf_cleanup
+
+.align 16
+.Lcossin_cossin_piby4:
+
+	movhlps	%xmm5,%xmm9
+	movhlps	%xmm7,%xmm13
+
+	movlhps	%xmm9,%xmm7
+	movlhps	%xmm13,%xmm5
+
+	movhlps	%xmm4,%xmm8
+	movhlps	%xmm6,%xmm12
+
+	movlhps	%xmm8,%xmm6
+	movlhps	%xmm12,%xmm4
+
+	jmp 	.L__vrsa_sincosf_cleanup
+
+.align 16
+.Lsincos_cossin_piby4:
+	movsd	%xmm5,%xmm9
+	movsd	%xmm7,%xmm13
+
+	movsd	%xmm9,%xmm7
+	movsd	%xmm13,%xmm5
+
+	movhlps	%xmm4,%xmm8
+	movhlps	%xmm6,%xmm12
+
+	movlhps	%xmm8,%xmm6
+	movlhps	%xmm12,%xmm4
+
+	jmp	.L__vrsa_sincosf_cleanup
+
+.align 16
+.Lsincos_sincos_piby4:
+	movsd	%xmm5,%xmm9
+	movsd	%xmm7,%xmm13
+
+	movsd	%xmm9,%xmm7
+	movsd	%xmm13,%xmm5
+
+	movsd	%xmm4,%xmm8
+	movsd	%xmm6,%xmm12
+
+	movsd	%xmm8,%xmm6
+	movsd	%xmm12,%xmm4
+
+	jmp 	.L__vrsa_sincosf_cleanup
+
+.align 16
+.Lcossin_sincos_piby4:
+	movhlps	%xmm5,%xmm9
+	movhlps	%xmm7,%xmm13
+
+	movlhps	%xmm9,%xmm7
+	movlhps	%xmm13,%xmm5
+
+	movsd	%xmm4,%xmm8
+	movsd	%xmm6,%xmm12
+
+	movsd	%xmm8,%xmm6
+	movsd	%xmm12,%xmm4
+
+	jmp	.L__vrsa_sincosf_cleanup
+
+.align 16
+.Lcoscos_sinsin_piby4:
+# Cos in %xmm5,%xmm4
+# Sin in %xmm7,%xmm6
+# Lower even, Upper odd, Swap upper
+
+	movapd	%xmm5,%xmm9
+	movapd	%xmm7,%xmm5
+	movapd	%xmm9,%xmm7
+
+	jmp 	.L__vrsa_sincosf_cleanup
+
+.align 16
+.Lsinsin_coscos_piby4:
+# Cos in %xmm5,%xmm4
+# Sin in %xmm7,%xmm6
+# Lower odd, Upper even, Swap lower
+
+	movapd	%xmm4,%xmm8
+	movapd	%xmm6,%xmm4
+	movapd	%xmm8,%xmm6
+
+	jmp 	.L__vrsa_sincosf_cleanup
+
+.align 16
+.Lcoscos_cossin_piby4:
+# Cos in xmm4 and xmm5
+# Sin in xmm6 and xmm7
+
+	movapd	%xmm5,%xmm9
+	movapd	%xmm7,%xmm5
+	movapd	%xmm9,%xmm7
+
+	movhlps	%xmm4,%xmm8
+	movhlps	%xmm6,%xmm12
+
+	movlhps	%xmm8,%xmm6
+	movlhps	%xmm12,%xmm4
+
+	jmp 	.L__vrsa_sincosf_cleanup
+
+.align 16
+.Lcoscos_sincos_piby4:
+# Cos in xmm4 and xmm5
+# Sin in xmm6 and xmm7
+
+	movapd	%xmm5,%xmm9
+	movapd	%xmm7,%xmm5
+	movapd	%xmm9,%xmm7
+
+	movsd	%xmm4,%xmm8
+	movsd	%xmm6,%xmm12
+
+	movsd	%xmm8,%xmm6
+	movsd	%xmm12,%xmm4
+	jmp 	.L__vrsa_sincosf_cleanup
+
+.align 16
+.Lcossin_coscos_piby4:
+# Cos in xmm4 and xmm5
+# Sin in xmm6 and xmm7
+
+	movapd	%xmm4,%xmm8
+	movapd	%xmm6,%xmm4
+	movapd	%xmm8,%xmm6
+
+	movhlps	%xmm5,%xmm9
+	movhlps	%xmm7,%xmm13
+
+	movlhps	%xmm9,%xmm7
+	movlhps	%xmm13,%xmm5
+
+	jmp 	.L__vrsa_sincosf_cleanup
+
+.align 16
+.Lcossin_sinsin_piby4:
+# Cos in xmm4 and xmm5
+# Sin in xmm6 and xmm7
+	movhlps	%xmm5,%xmm9
+	movhlps	%xmm7,%xmm13
+
+	movlhps	%xmm9,%xmm7
+	movlhps	%xmm13,%xmm5
+
+	jmp 	.L__vrsa_sincosf_cleanup
+
+
+.align 16
+.Lsincos_coscos_piby4:
+# Cos in xmm4 and xmm5
+# Sin in xmm6 and xmm7
+	movapd	%xmm4,%xmm8
+	movapd	%xmm6,%xmm4
+	movapd	%xmm8,%xmm6
+
+	movsd	%xmm5,%xmm9
+	movsd	%xmm7,%xmm13
+
+	movsd	%xmm9,%xmm7
+	movsd	%xmm13,%xmm5
+	jmp 	.L__vrsa_sincosf_cleanup
+
+.align 16
+.Lsincos_sinsin_piby4:
+# Cos in xmm4 and xmm5
+# Sin in xmm6 and xmm7
+	movsd	%xmm5,%xmm9
+	movsd	%xmm7,%xmm5
+	movsd	%xmm9,%xmm7
+
+	jmp 	.L__vrsa_sincosf_cleanup
+
+.align 16
+.Lsinsin_cossin_piby4:
+# Cos in xmm4 and xmm5
+# Sin in xmm6 and xmm7
+	movhlps	%xmm4,%xmm8
+	movhlps	%xmm6,%xmm12
+
+	movlhps	%xmm8,%xmm6
+	movlhps	%xmm12,%xmm4
+
+	jmp 	.L__vrsa_sincosf_cleanup
+
+.align 16
+.Lsinsin_sincos_piby4:
+# Cos in xmm4 and xmm5
+# Sin in xmm6 and xmm7
+	movsd	%xmm4,%xmm8
+	movsd	%xmm6,%xmm4
+	movsd	%xmm8,%xmm6
+	jmp 	.L__vrsa_sincosf_cleanup
+
+.align 16
+.Lsinsin_sinsin_piby4:
+# Cos in xmm4 and xmm5
+# Sin in xmm6 and xmm7
+# Lower and Upper odd, So Swap
+
+	jmp 	.L__vrsa_sincosf_cleanup
diff --git a/src/gas/vrsasinf.S b/src/gas/vrsasinf.S
new file mode 100644
index 0000000..6cbff59
--- /dev/null
+++ b/src/gas/vrsasinf.S
@@ -0,0 +1,2441 @@
+
+#
+#  (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+#
+#  This file is part of libacml_mv.
+#
+#  libacml_mv is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  libacml_mv 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
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with libacml_mv.  If not, see
+#  <http://www.gnu.org/licenses/>.
+#
+#
+
+
+
+
+
+#
+# vrsasinf.s
+#
+# A vector implementation of the sin libm function.
+#
+# Prototype:
+#
+#    vrsa_sinf(int n, float* x, float* y);
+#
+# Computes Sine of x for an array of input values.
+# Places the results into the supplied y array.
+# Does not perform error checking.
+# Denormal inputs may produce unexpected results.
+# This inlines a routine that computes 4 single precision Sine values at a time.
+# The four values are passed as packed single in xmm10.
+# The four results are returned as packed singles in xmm10.
+# Note that this represents a non-standard ABI usage, as no ABI
+# ( and indeed C) currently allows returning 2 values for a function.
+# It is expected that some compilers may be able to take advantage of this
+# interface when implementing vectorized loops.  Using the array implementation
+# of the routine requires putting the inputs into memory, and retrieving
+# the results from memory.  This routine eliminates the need for this
+# overhead if the data does not already reside in memory.
+# Author: Harsha Jagasia
+# Email:  harsha.jagasia@amd.com
+
+#ifdef __ELF__
+.section .note.GNU-stack,"",@progbits
+#endif
+
+.data
+.align 64
+.L__real_7fffffffffffffff: .quad 0x07fffffffffffffff	#Sign bit zero
+			.quad 0x07fffffffffffffff
+.L__real_3ff0000000000000: .quad 0x03ff0000000000000	# 1.0
+			.quad 0x03ff0000000000000
+.L__real_v2p__27:		.quad 0x03e40000000000000	# 2p-27
+			.quad 0x03e40000000000000
+.L__real_3fe0000000000000: .quad 0x03fe0000000000000	# 0.5
+			.quad 0x03fe0000000000000
+.L__real_3fc5555555555555: .quad 0x03fc5555555555555	# 0.166666666666
+			.quad 0x03fc5555555555555
+.L__real_3fe45f306dc9c883: .quad 0x03fe45f306dc9c883	# twobypi
+			.quad 0x03fe45f306dc9c883
+.L__real_3ff921fb54400000: .quad 0x03ff921fb54400000	# piby2_1
+			.quad 0x03ff921fb54400000
+.L__real_3dd0b4611a626331: .quad 0x03dd0b4611a626331	# piby2_1tail
+			.quad 0x03dd0b4611a626331
+.L__real_3dd0b4611a600000: .quad 0x03dd0b4611a600000	# piby2_2
+			.quad 0x03dd0b4611a600000
+.L__real_3ba3198a2e037073: .quad 0x03ba3198a2e037073	# piby2_2tail
+			.quad 0x03ba3198a2e037073
+.L__real_fffffffff8000000: .quad 0x0fffffffff8000000	# mask for stripping head and tail
+			.quad 0x0fffffffff8000000
+.L__real_8000000000000000:	.quad 0x08000000000000000	# -0  or signbit
+			.quad 0x08000000000000000
+.L__reald_one_one:		.quad 0x00000000100000001	#
+			.quad 0
+.L__reald_two_two:		.quad 0x00000000200000002	#
+			.quad 0
+.L__reald_one_zero:	.quad 0x00000000100000000	# sin_cos_filter
+			.quad 0
+.L__reald_zero_one:	.quad 0x00000000000000001	#
+			.quad 0
+.L__reald_two_zero:	.quad 0x00000000200000000	#
+			.quad 0
+.L__realq_one_one:		.quad 0x00000000000000001	#
+			.quad 0x00000000000000001	#
+.L__realq_two_two:		.quad 0x00000000000000002	#
+			.quad 0x00000000000000002	#
+.L__real_1_x_mask:		.quad 0x0ffffffffffffffff	#
+			.quad 0x03ff0000000000000	#
+.L__real_zero:		.quad 0x00000000000000000	#
+			.quad 0x00000000000000000	#
+.L__real_one:		.quad 0x00000000000000001	#
+			.quad 0x00000000000000001	#
+
+.Lcosarray:
+	.quad	0x03FA5555555502F31		#  0.0416667			c1
+	.quad	0x03FA5555555502F31
+	.quad	0x0BF56C16BF55699D7		# -0.00138889			c2
+	.quad	0x0BF56C16BF55699D7
+	.quad	0x03EFA015C50A93B49		#  2.48016e-005			c3
+	.quad	0x03EFA015C50A93B49
+	.quad	0x0BE92524743CC46B8		# -2.75573e-007			c4
+	.quad	0x0BE92524743CC46B8
+
+.Lsinarray:
+	.quad	0x0BFC555555545E87D		# -0.166667	   		s1
+	.quad	0x0BFC555555545E87D
+	.quad	0x03F811110DF01232D		# 0.00833333	   		s2
+	.quad	0x03F811110DF01232D
+	.quad	0x0BF2A013A88A37196		# -0.000198413			s3
+	.quad	0x0BF2A013A88A37196
+	.quad	0x03EC6DBE4AD1572D5		# 2.75573e-006			s4
+	.quad	0x03EC6DBE4AD1572D5
+
+.Lsincosarray:
+	.quad	0x0BFC555555545E87D		# -0.166667	   		s1
+	.quad	0x03FA5555555502F31		# 0.0416667		   	c1
+	.quad	0x03F811110DF01232D		# 0.00833333	   		s2
+	.quad	0x0BF56C16BF55699D7
+	.quad	0x0BF2A013A88A37196		# -0.000198413			s3
+	.quad	0x03EFA015C50A93B49
+	.quad	0x03EC6DBE4AD1572D5		# 2.75573e-006			s4
+	.quad	0x0BE92524743CC46B8
+
+.Lcossinarray:
+	.quad	0x03FA5555555502F31		# 0.0416667		   	c1
+	.quad	0x0BFC555555545E87D		# -0.166667	   		s1
+	.quad	0x0BF56C16BF55699D7		#				c2
+	.quad	0x03F811110DF01232D
+	.quad	0x03EFA015C50A93B49		#				c3
+	.quad	0x0BF2A013A88A37196
+	.quad	0x0BE92524743CC46B8		#				c4
+	.quad	0x03EC6DBE4AD1572D5
+
+.align 8
+	.Levensin_oddcos_tbl:
+
+		.quad	.Lsinsin_sinsin_piby4		# 0		*	; Done
+		.quad	.Lsinsin_sincos_piby4		# 1		+	; Done
+		.quad	.Lsinsin_cossin_piby4		# 2			; Done
+		.quad	.Lsinsin_coscos_piby4		# 3		+	; Done
+
+		.quad	.Lsincos_sinsin_piby4		# 4			; Done
+		.quad	.Lsincos_sincos_piby4		# 5		*	; Done
+		.quad	.Lsincos_cossin_piby4		# 6			; Done
+		.quad	.Lsincos_coscos_piby4		# 7			; Done
+
+		.quad	.Lcossin_sinsin_piby4		# 8			; Done
+		.quad	.Lcossin_sincos_piby4		# 9			; TBD
+		.quad	.Lcossin_cossin_piby4		# 10		*	; Done
+		.quad	.Lcossin_coscos_piby4		# 11			; Done
+
+		.quad	.Lcoscos_sinsin_piby4		# 12			; Done
+		.quad	.Lcoscos_sincos_piby4		# 13		+	; Done
+		.quad	.Lcoscos_cossin_piby4		# 14			; Done
+		.quad	.Lcoscos_coscos_piby4		# 15		*	; Done
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+        .weak vrsa_sinf_
+        .set vrsa_sinf_,__vrsa_sinf__
+        .weak vrsa_sinf__
+        .set vrsa_sinf__,__vrsa_sinf__
+
+    .text
+    .align 16
+    .p2align 4,,15
+
+#FORTRAN subroutine implementation of array sin
+#VRSA_SINF(N,X,Y)
+#C equivalent*/
+#void vrsa_sinf__(int * n, double *x, double *y)
+#{
+#       vrsa_sinf(*n,x,y);
+#}
+
+.globl __vrsa_sinf__
+    .type   __vrsa_sinf__,@function
+__vrsa_sinf__:
+    mov         (%rdi),%edi
+
+    .align 16
+    .p2align 4,,15
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# define local variable storage offsets
+.equ	p_temp,0		# temporary for get/put bits operation
+.equ	p_temp1,0x10		# temporary for get/put bits operation
+
+.equ	save_xmm6,0x20		# temporary for get/put bits operation
+.equ	save_xmm7,0x30		# temporary for get/put bits operation
+.equ	save_xmm8,0x40		# temporary for get/put bits operation
+.equ	save_xmm9,0x50		# temporary for get/put bits operation
+.equ	save_xmm0,0x60		# temporary for get/put bits operation
+.equ	save_xmm11,0x70		# temporary for get/put bits operation
+.equ	save_xmm12,0x80		# temporary for get/put bits operation
+.equ	save_xmm13,0x90		# temporary for get/put bits operation
+.equ	save_xmm14,0x0A0		# temporary for get/put bits operation
+.equ	save_xmm15,0x0B0		# temporary for get/put bits operation
+
+.equ	r,0x0C0		# pointer to r for remainder_piby2
+.equ	rr,0x0D0		# pointer to r for remainder_piby2
+.equ	region,0x0E0		# pointer to r for remainder_piby2
+
+.equ	r1,0x0F0		# pointer to r for remainder_piby2
+.equ	rr1,0x0100		# pointer to r for remainder_piby2
+.equ	region1,0x0110		# pointer to r for remainder_piby2
+
+.equ	p_temp2,0x0120		# temporary for get/put bits operation
+.equ	p_temp3,0x0130		# temporary for get/put bits operation
+
+.equ	p_temp4,0x0140		# temporary for get/put bits operation
+.equ	p_temp5,0x0150		# temporary for get/put bits operation
+
+.equ	p_original,0x0160		# original x
+.equ	p_mask,0x0170		# original x
+.equ	p_sign,0x0180		# original x
+
+.equ	p_original1,0x0190		# original x
+.equ	p_mask1,0x01A0		# original x
+.equ	p_sign1,0x01B0		# original x
+
+.equ	save_r12,0x01C0		# temporary for get/put bits operation
+.equ	save_r13,0x01D0		# temporary for get/put bits operation
+
+.equ	save_xa,0x01E0		#qword
+.equ	save_ya,0x01F0		#qword
+
+.equ	save_nv,0x0200		#qword
+.equ	p_iter,0x0210		# qword	storage for number of loop iterations
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.globl vrsa_sinf
+    .type   vrsa_sinf,@function
+vrsa_sinf:
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# parameters are passed in by Linux as:
+# rcx - int n
+# rdx - double *x
+# r8  - double *y
+
+	sub	$0x0228,%rsp
+	mov	%r12,save_r12(%rsp)	# save r12
+	mov	%r13,save_r13(%rsp)	# save r13
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#START PROCESS INPUT
+# save the arguments
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+	mov		%rdx,save_ya(%rsp)	# save y_array pointer
+#ifdef INTEGER64
+        mov             %rdi,%rax
+#else
+        mov             %edi,%eax
+        mov             %rax,%rdi
+#endif
+	mov		%rdi,save_nv(%rsp)	# save number of values
+# see if too few values to call the main loop
+	shr		$2,%rax			# get number of iterations
+	jz		.L__vrsa_cleanup		# jump if only single calls
+# prepare the iteration counts
+	mov		%rax,p_iter(%rsp)	# save number of iterations
+	shl		$2,%rax
+	sub		%rax,%rdi		# compute number of extra single calls
+	mov		%rdi,save_nv(%rsp)	# save number of left over values
+
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#START LOOP
+.align 16
+.L__vrsa_top:
+# build the input _m128d
+	mov		save_xa(%rsp),%rsi	# get x_array pointer
+	movlps	(%rsi),%xmm0
+	movhps	8(%rsi),%xmm0
+
+	prefetch	32(%rsi)
+	add		$16,%rsi
+	mov		%rsi,save_xa(%rsp)	# save x_array pointer
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# V4 START
+	movhlps		%xmm0,%xmm8
+	cvtps2pd	%xmm0,%xmm10			# convert input to double.
+	cvtps2pd	%xmm8,%xmm1			# convert input to double.
+
+movdqa	%xmm10,%xmm6
+movdqa	%xmm1,%xmm7
+movapd	.L__real_7fffffffffffffff(%rip),%xmm2
+
+andpd 	%xmm2,%xmm10	#Unsign
+andpd 	%xmm2,%xmm1	#Unsign
+
+movd	%xmm10,%rax				#rax is lower arg
+movhpd	%xmm10, p_temp+8(%rsp)			#
+mov    	p_temp+8(%rsp),%rcx			#rcx = upper arg
+
+movd	%xmm1,%r8				#r8 is lower arg
+movhpd	%xmm1, p_temp1+8(%rsp)			#
+mov    	p_temp1+8(%rsp),%r9			#r9 = upper arg
+
+movdqa	%xmm10,%xmm12
+movdqa	%xmm1,%xmm13
+
+pcmpgtd		%xmm6,%xmm12
+pcmpgtd		%xmm7,%xmm13
+movdqa		%xmm12,%xmm6
+movdqa		%xmm13,%xmm7
+psrldq		$4,%xmm12
+psrldq		$4,%xmm13
+psrldq		$8,%xmm6
+psrldq		$8,%xmm7
+
+mov 	$0x3FE921FB54442D18,%rdx			#piby4	+
+mov	$0x411E848000000000,%r10			#5e5	+
+movapd	.L__real_3fe0000000000000(%rip),%xmm4		#0.5 for later use +
+
+por	%xmm6,%xmm12
+por	%xmm7,%xmm13
+movd	%xmm12,%r12				#Move Sign to gpr **
+movd	%xmm13,%r13				#Move Sign to gpr **
+
+movapd	%xmm10,%xmm2				#x0
+movapd	%xmm1,%xmm3				#x1
+movapd	%xmm10,%xmm6				#x0
+movapd	%xmm1,%xmm7				#x1
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm2 = x, xmm4 =0.5/t, xmm6 =x
+# xmm3 = x, xmm5 =0.5/t, xmm7 =x
+.align 16
+.Leither_or_both_arg_gt_than_piby4:
+	cmp	%r10,%rax
+	jae	.Lfirst_or_next3_arg_gt_5e5
+
+	cmp	%r10,%rcx
+	jae	.Lsecond_or_next2_arg_gt_5e5
+
+	cmp	%r10,%r8
+	jae	.Lthird_or_fourth_arg_gt_5e5
+
+	cmp	%r10,%r9
+	jae	.Lfourth_arg_gt_5e5
+
+
+#      /* Find out what multiple of piby2 */
+#        npi2  = (int)(x * twobypi + 0.5);
+	movapd	.L__real_3fe45f306dc9c883(%rip),%xmm10
+	mulpd	%xmm10,%xmm2						# * twobypi
+	mulpd	%xmm10,%xmm3						# * twobypi
+
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	addpd	%xmm4,%xmm3						# +0.5, npi2
+
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm10		# piby2_1
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm1		# piby2_1
+
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	cvttpd2dq	%xmm3,%xmm5					# convert packed double to packed integers
+
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm9		# piby2_2
+
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+	cvtdq2pd	%xmm5,%xmm3					# and back to double.
+
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+
+	movd	%xmm4,%r8						# Region
+	movd	%xmm5,%r9						# Region
+
+	mov 	.L__reald_one_zero(%rip),%rdx			#compare value for cossin path
+	mov	%r8,%r10
+	mov	%r9,%r11
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm10						# npi2 * piby2_1;
+       mulpd	%xmm3,%xmm1						# npi2 * piby2_1;
+
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+       mulpd	%xmm3,%xmm9						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm10,%xmm6						# rhead  = x - npi2 * piby2_1;
+       subpd	%xmm1,%xmm7						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm10						# t
+       movapd	%xmm7,%xmm1						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm10						# rhead
+       subpd	%xmm9,%xmm1						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm3		# npi2 * piby2_2tail
+
+       subpd	%xmm10,%xmm6						# t-rhead
+       subpd	%xmm1,%xmm7						# t-rhead
+
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       subpd	%xmm7,%xmm9						# - ((t - rhead) - rtail)
+
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       addpd	%xmm3,%xmm9						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm4  = npi2 (int), xmm10 =rhead, xmm8 =rtail
+# xmm5  = npi2 (int), xmm1 =rhead, xmm9 =rtail
+
+	and	.L__reald_one_one(%rip),%r8		#odd/even region for cos/sin
+	and	.L__reald_one_one(%rip),%r9		#odd/even region for cos/sin
+
+	shr	$1,%r10						#~AB+A~B, A is sign and B is upper bit of region
+	shr	$1,%r11						#~AB+A~B, A is sign and B is upper bit of region
+
+	mov	%r10,%rax
+	mov	%r11,%rcx
+
+	not 	%r12						#ADDED TO CHANGE THE LOGIC
+	not 	%r13						#ADDED TO CHANGE THE LOGIC
+	and	%r12,%r10
+	and	%r13,%r11
+
+	not	%rax
+	not	%rcx
+	not	%r12
+	not	%r13
+	and	%r12,%rax
+	and	%r13,%rcx
+
+	or	%rax,%r10
+	or	%rcx,%r11
+	and	.L__reald_one_one(%rip),%r10				#(~AB+A~B)&1
+	and	.L__reald_one_one(%rip),%r11				#(~AB+A~B)&1
+
+	mov	%r10,%r12
+	mov	%r11,%r13
+
+	and	%rdx,%r12				#mask out the lower sign bit leaving the upper sign bit
+	and	%rdx,%r13				#mask out the lower sign bit leaving the upper sign bit
+
+	shl	$63,%r10				#shift lower sign bit left by 63 bits
+	shl	$63,%r11				#shift lower sign bit left by 63 bits
+	shl	$31,%r12				#shift upper sign bit left by 31 bits
+	shl	$31,%r13				#shift upper sign bit left by 31 bits
+
+	mov 	 %r10,p_sign(%rsp)		#write out lower sign bit
+	mov 	 %r12,p_sign+8(%rsp)		#write out upper sign bit
+	mov 	 %r11,p_sign1(%rsp)		#write out lower sign bit
+	mov 	 %r13,p_sign1+8(%rsp)		#write out upper sign bit
+
+# GET_BITS_DP64(rhead-rtail, uy);			   		; originally only rhead
+# xmm4  = Sign, xmm10 =rhead, xmm8 =rtail
+# xmm5  = Sign, xmm1 =rhead, xmm9 =rtail
+	movapd	%xmm10,%xmm6						# rhead
+	movapd	%xmm1,%xmm7						# rhead
+
+	subpd	%xmm8,%xmm10						# r = rhead - rtail
+	subpd	%xmm9,%xmm1						# r = rhead - rtail
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# xmm4  = Sign, xmm10 = r, xmm6 =rhead, xmm8 =rtail
+# xmm5  = Sign, xmm1 = r, xmm7 =rhead, xmm9 =rtail
+
+	mov	%r8,%rax
+	mov	%r9,%rcx
+
+	movapd	%xmm10,%xmm2				# move r for r2
+	movapd	%xmm1,%xmm3				# move r for r2
+
+	mulpd	%xmm10,%xmm2				# r2
+	mulpd	%xmm1,%xmm3				# r2
+
+	and	.L__reald_zero_one(%rip),%rax
+	and	.L__reald_zero_one(%rip),%rcx
+	shr	$31,%r8
+	shr	$31,%r9
+	or	%r8,%rax
+	or	%r9,%rcx
+	shl	$2,%rcx
+	or	%rcx,%rax
+
+	lea	.Levensin_oddcos_tbl(%rip),%rcx
+	jmp	*(%rcx,%rax,8)				#Jmp table for cos/sin calculation based on even/odd region
+
+
+
+
+
+
+
+
+
+
+
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lfirst_or_next3_arg_gt_5e5:
+# %rcx,,%rax r8, r9
+
+	cmp	%r10,%rcx				#is upper arg >= 5e5
+	jae	.Lboth_arg_gt_5e5
+
+.Llower_arg_gt_5e5:
+# Upper Arg is < 5e5, Lower arg is >= 5e5
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+# Be sure not to use %xmm3,%xmm1 and xmm7
+# Use %xmm8,,%xmm5 xmm0, xmm12
+#	    %xmm11,,%xmm9 xmm13
+
+
+	movlpd	 %xmm10,r(%rsp)		#Save lower fp arg for remainder_piby2 call
+	movhlps	%xmm10,%xmm10			#Needed since we want to work on upper arg
+	movhlps	%xmm2,%xmm2
+	movhlps	%xmm6,%xmm6
+
+# Work on Upper arg
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm4,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm8		# xmm8 = piby2_1
+	cvttsd2si	%xmm2,%ecx				# ecx = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm0		# xmm0 = piby2_2
+	cvtsi2sd	%ecx,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm8					# npi2 * piby2_1
+	subsd	%xmm8,%xmm6					# xmm6 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm12		# xmm12 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm6,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm0					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm0,%xmm6					# xmm6 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm12     					# npi2 * piby2_2tail
+       subsd	%xmm6,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm0					# (rtail-(t-rhead))
+       addsd	%xmm12,%xmm0					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %ecx,region+4(%rsp)			# store upper region
+       movsd	%xmm6,%xmm10
+       subsd	%xmm0,%xmm10					# xmm10 = r=(rhead-rtail)
+       movlpd	 %xmm10,r+8(%rsp)			# store upper r
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#Note that volatiles will be trashed by the call
+#We will construct r, rr, region and sign
+
+# Work on Lower arg
+	mov		$0x07ff0000000000000,%r11			# is lower arg nan/inf
+	mov		%r11,%r10
+	and		%rax,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sinf_lower_naninf
+
+	mov	  %r8,p_temp(%rsp)
+	mov	  %r9,p_temp2(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region(%rsp),%rdx			# lower arg is **NOT** nan/inf
+	lea	 r(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	mov	 r(%rsp),%rdi	#Restore lower fp arg for remainder_piby2 call
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	 p_temp(%rsp),%r8
+	mov	 p_temp2(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+	jmp 	0f
+
+.L__vrs4_sinf_lower_naninf:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rax
+	mov	 %rax,r(%rsp)				# r = x | 0x0008000000000000
+	mov	 %r10d,region(%rsp)			# region =0
+
+.align 16
+0:
+	jmp 	.Lcheck_next2_args
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lboth_arg_gt_5e5:
+#Upper Arg is >= 5e5, Lower arg is >= 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+
+	movhlps %xmm10,%xmm6		#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r11			#is lower arg nan/inf
+	mov		%r11,%r10
+	and		%rax,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sinf_lower_naninf_of_both_gt_5e5
+
+	mov	  %rcx,p_temp(%rsp)			#Save upper arg
+	mov	  %r8,p_temp2(%rsp)
+	mov	  %r9,p_temp4(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	 r(%rsp),%rsi
+
+# added ins- changed input from xmm10 to xmm0
+	movd	 %xmm10,%rdi
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	 p_temp2(%rsp),%r8
+	mov	 p_temp4(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+
+	mov	 p_temp(%rsp),%rcx			#Restore upper arg
+	jmp 	0f
+
+.L__vrs4_sinf_lower_naninf_of_both_gt_5e5:				#lower arg is nan/inf
+#	mov	.LQWORD,%rax PTR p_original[rsp]
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rax
+	mov	 %rax,r(%rsp)				#r = x | 0x0008000000000000
+	mov	 %r10d,region(%rsp)			#region = 0
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r11			#is upper arg nan/inf
+	mov		%r11,%r10
+	and		%rcx,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sinf_upper_naninf_of_both_gt_5e5
+
+
+	mov	  %r8,p_temp2(%rsp)
+	mov	  %r9,p_temp4(%rsp)
+	movapd	  %xmm1,p_temp1(%rsp)
+	movapd	  %xmm3,p_temp3(%rsp)
+	movapd	  %xmm7,p_temp5(%rsp)
+
+	lea	 region+4(%rsp),%rdx			#upper arg is **NOT** nan/inf
+	lea	 r+8(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	movd	 %xmm6,%rdi
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	 p_temp2(%rsp),%r8
+	mov	 p_temp4(%rsp),%r9
+	movapd	 p_temp1(%rsp),%xmm1
+	movapd	 p_temp3(%rsp),%xmm3
+	movapd	 p_temp5(%rsp),%xmm7
+
+	jmp 	0f
+
+.L__vrs4_sinf_upper_naninf_of_both_gt_5e5:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rcx
+	mov	 %rcx,r+8(%rsp)				#r = x | 0x0008000000000000
+	mov	 %r10d,region+4(%rsp)			#region = 0
+
+.align 16
+0:
+	jmp 	.Lcheck_next2_args
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lsecond_or_next2_arg_gt_5e5:
+
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+# Do not use %xmm3,,%xmm1 xmm7
+# Restore xmm4 and %xmm3,,%xmm1 xmm7
+# Can use %xmm0,,%xmm8 xmm12
+#   %xmm9,,%xmm5 xmm11, xmm13
+
+	movhpd	 %xmm10,r+8(%rsp)	#Save upper fp arg for remainder_piby2 call
+
+# Work on Lower arg
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# x*twobypi
+	addsd	%xmm4,%xmm2					# xmm2 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm8		# xmm3 = piby2_1
+	cvttsd2si	%xmm2,%eax				# ecx = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm0		# xmm1 = piby2_2
+	cvtsi2sd	%eax,%xmm2				# xmm2 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm2,%xmm8					# npi2 * piby2_1
+	subsd	%xmm8,%xmm6					# xmm6 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm12		# xmm7 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm6,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm2,%xmm0					# xmm1 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm0,%xmm6					# xmm6 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm2,%xmm12     				# npi2 * piby2_2tail
+       subsd	%xmm6,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm0					# (rtail-(t-rhead))
+       addsd	%xmm12,%xmm0					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %eax,region(%rsp)			# store upper region
+
+        subsd	%xmm0,%xmm6					# xmm10 = r=(rhead-rtail)
+
+        movlpd	 %xmm6,r(%rsp)				# store upper r
+
+
+#Work on Upper arg
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+	mov		$0x07ff0000000000000,%r11			# is upper arg nan/inf
+	mov		%r11,%r10
+	and		%rcx,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sinf_upper_naninf
+
+	mov	 %r8,p_temp(%rsp)
+	mov	 %r9,p_temp2(%rsp)
+	movapd	 %xmm1,p_temp1(%rsp)
+	movapd	 %xmm3,p_temp3(%rsp)
+	movapd	 %xmm7,p_temp5(%rsp)
+
+	lea	 region+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 r+8(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	mov	 r+8(%rsp),%rdi
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	p_temp(%rsp),%r8
+	mov	p_temp2(%rsp),%r9
+	movapd	p_temp1(%rsp),%xmm1
+	movapd	p_temp3(%rsp),%xmm3
+	movapd	p_temp5(%rsp),%xmm7
+	jmp 	0f
+
+.L__vrs4_sinf_upper_naninf:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%rcx
+	mov	 %rcx,r+8(%rsp)				# r = x | 0x0008000000000000
+	mov	 %r10d,region+4(%rsp)			# region =0
+
+.align 16
+0:
+	jmp 	.Lcheck_next2_args
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcheck_next2_args:
+
+	mov	$0x411E848000000000,%r10			#5e5	+
+
+	cmp	%r10,%r8
+	jae	.Lfirst_second_done_third_or_fourth_arg_gt_5e5
+
+	cmp	%r10,%r9
+	jae	.Lfirst_second_done_fourth_arg_gt_5e5
+
+
+
+# Work on next two args, both < 5e5
+# %xmm3,,%xmm1 xmm5 = x, xmm4 = 0.5
+
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4			#Restore 0.5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm3			# * twobypi
+	addpd	%xmm4,%xmm3						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm1		# piby2_1
+	cvttpd2dq	%xmm3,%xmm5					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm9		# piby2_2
+	cvtdq2pd	%xmm5,%xmm3					# and back to double.
+
+###
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movlpd	 %xmm5,region1(%rsp)						# Region
+###
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm3,%xmm1						# npi2 * piby2_1;
+
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm3,%xmm9						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm1,%xmm7						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm7,%xmm1						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm9,%xmm1						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm3		# npi2 * piby2_2tail
+
+       subpd	%xmm1,%xmm7						# t-rhead
+       subpd	%xmm7,%xmm9						# - ((t - rhead) - rtail)
+       addpd	%xmm3,%xmm9						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+#       movapd	%xmm1,%xmm7						; rhead
+       subpd	%xmm9,%xmm1						# r = rhead - rtail
+       movapd	 %xmm1,r1(%rsp)
+
+#       subpd	%xmm1,%xmm7						; rr=rhead-r
+#       subpd	xmm7, xmm9						; rr=(rhead-r) -rtail
+#       movapd	OWORD PTR rr1[rsp], xmm7
+
+	jmp	.L__vrs4_sinf_reconstruct
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lthird_or_fourth_arg_gt_5e5:
+#first two args are < 5e5, third arg >= 5e5, fourth arg >= 5e5 or < 5e5
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+# Do not use %xmm3,,%xmm1 xmm7
+# Can use 	%xmm11,,%xmm9 xmm13
+# 	%xmm8,,%xmm5 xmm0, xmm12
+# Restore xmm4
+
+# Work on first two args, both < 5e5
+
+
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# * twobypi
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm10		# piby2_1
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+
+###
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movlpd	 %xmm4,region(%rsp)				# Region
+###
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm10						# npi2 * piby2_1;
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm10,%xmm6						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm10						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm10						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+
+       subpd	%xmm10,%xmm6						# t-rhead
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+#       movapd	%xmm10,%xmm6						; rhead
+       subpd	%xmm8,%xmm10						# r = rhead - rtail
+       movapd	 %xmm10,r(%rsp)
+
+#       subpd	%xmm10,%xmm6						; rr=rhead-r
+#       subpd	xmm6, xmm8						; rr=(rhead-r) -rtail
+#       movapd	OWORD PTR rr[rsp], xmm6
+
+
+# Work on next two args, third arg >= 5e5, fourth arg >= 5e5 or < 5e5
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lfirst_second_done_third_or_fourth_arg_gt_5e5:
+# %rcx,,%rax r8, r9
+# %xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+
+
+	mov	$0x411E848000000000,%r10			#5e5	+
+	cmp	%r10,%r9
+	jae	.Lboth_arg_gt_5e5_higher
+
+
+# Upper Arg is <5e5, Lower arg is >= 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+	movlpd	 %xmm1,r1(%rsp)		#Save lower fp arg for remainder_piby2 call
+	movhlps	%xmm1,%xmm1			#Needed since we want to work on upper arg
+	movhlps	%xmm3,%xmm3
+	movhlps	%xmm7,%xmm7
+
+
+# Work on Upper arg
+# Lower arg might contain nan/inf, to avoid exception use only scalar instructions on upper arg which has been moved to lower portions of fp regs
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4		# Restore 0.5
+
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm3		# x*twobypi
+	addsd	%xmm4,%xmm3					# xmm3 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm2		# xmm2 = piby2_1
+	cvttsd2si	%xmm3,%r9d				# r9d = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm10		# xmm10 = piby2_2
+	cvtsi2sd	%r9d,%xmm3				# xmm3 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm3,%xmm2					# npi2 * piby2_1
+	subsd	%xmm2,%xmm7					# xmm7 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm7,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm3,%xmm10					# xmm10 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm10,%xmm7					# xmm7 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm3,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm7,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm10					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm10					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %r9d,region1+4(%rsp)			# store upper region
+
+       subsd	%xmm10,%xmm7					# xmm1 = r=(rhead-rtail)
+
+       movlpd	 %xmm7,r1+8(%rsp)			# store upper r
+
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+
+# Work on Lower arg
+	mov		$0x07ff0000000000000,%r11			# is lower arg nan/inf
+	mov		%r11,%r10
+	and		%r8,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sinf_lower_naninf_higher
+
+	lea	 region1(%rsp),%rdx			# lower arg is **NOT** nan/inf
+	lea	 r1(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+  	mov	 r1(%rsp),%rdi
+
+	call	 __remainder_piby2d2f@PLT
+
+	jmp 	0f
+
+.L__vrs4_sinf_lower_naninf_higher:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r8
+	mov	 %r8,r1(%rsp)				# r = x | 0x0008000000000000
+	mov	 %r10d,region1(%rsp)			# region =0
+
+.align 16
+0:
+	jmp 	.L__vrs4_sinf_reconstruct
+
+
+
+
+
+
+
+.align 16
+.Lboth_arg_gt_5e5_higher:
+# Upper Arg is >= 5e5, Lower arg is >= 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+
+	movhlps %xmm1,%xmm7		#Save upper fp arg for remainder_piby2 call
+
+	mov		$0x07ff0000000000000,%r11			#is lower arg nan/inf
+	mov		%r11,%r10
+	and		%r8,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sinf_lower_naninf_of_both_gt_5e5_higher
+
+	mov	  %r9,p_temp1(%rsp)			#Save upper arg
+	lea	 region1(%rsp),%rdx			#lower arg is **NOT** nan/inf
+	lea	 r1(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	movd	 %xmm1,%rdi
+
+	call	 __remainder_piby2d2f@PLT
+
+	mov	 p_temp1(%rsp),%r9			#Restore upper arg
+
+	jmp 	0f
+
+.L__vrs4_sinf_lower_naninf_of_both_gt_5e5_higher:				#lower arg is nan/inf
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r8
+	mov	 %r8,r1(%rsp)				#r = x | 0x0008000000000000
+	mov	 %r10d,region1(%rsp)			#region = 0
+
+.align 16
+0:
+	mov		$0x07ff0000000000000,%r11			#is upper arg nan/inf
+	mov		%r11,%r10
+	and		%r9,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sinf_upper_naninf_of_both_gt_5e5_higher
+
+	lea	 region1+4(%rsp),%rdx			#upper arg is **NOT** nan/inf
+	lea	 r1+8(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	movd	 %xmm7,%rdi
+
+	call	 __remainder_piby2d2f@PLT
+
+	jmp 	0f
+
+.L__vrs4_sinf_upper_naninf_of_both_gt_5e5_higher:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r9
+	mov	 %r9,r1+8(%rsp)				#r = x | 0x0008000000000000
+	mov	 %r10d,region1+4(%rsp)			#region = 0
+
+.align 16
+0:
+	jmp 	.L__vrs4_sinf_reconstruct
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lfourth_arg_gt_5e5:
+#first two args are < 5e5, third arg < 5e5, fourth arg >= 5e5
+#%rcx,,%rax r8, r9
+#%xmm2,,%xmm10 xmm6 = x, xmm4 = 0.5
+
+# Work on first two args, both < 5e5
+
+	mulpd	.L__real_3fe45f306dc9c883(%rip),%xmm2		# * twobypi
+	addpd	%xmm4,%xmm2						# +0.5, npi2
+	movapd	.L__real_3ff921fb54400000(%rip),%xmm10		# piby2_1
+	cvttpd2dq	%xmm2,%xmm4					# convert packed double to packed integers
+	movapd	.L__real_3dd0b4611a600000(%rip),%xmm8		# piby2_2
+	cvtdq2pd	%xmm4,%xmm2					# and back to double.
+
+###
+#      /* Subtract the multiple from x to get an extra-precision remainder */
+	movlpd	 %xmm4,region(%rsp)				# Region
+###
+
+#      rhead  = x - npi2 * piby2_1;
+       mulpd	%xmm2,%xmm10						# npi2 * piby2_1;
+#      rtail  = npi2 * piby2_2;
+       mulpd	%xmm2,%xmm8						# rtail
+
+#      rhead  = x - npi2 * piby2_1;
+       subpd	%xmm10,%xmm6						# rhead  = x - npi2 * piby2_1;
+
+#      t  = rhead;
+       movapd	%xmm6,%xmm10						# t
+
+#      rhead  = t - rtail;
+       subpd	%xmm8,%xmm10						# rhead
+
+#      rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulpd	.L__real_3ba3198a2e037073(%rip),%xmm2		# npi2 * piby2_2tail
+
+       subpd	%xmm10,%xmm6						# t-rhead
+       subpd	%xmm6,%xmm8						# - ((t - rhead) - rtail)
+       addpd	%xmm2,%xmm8						# rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
+
+#       movapd	%xmm10,%xmm6						; rhead
+       subpd	%xmm8,%xmm10						# r = rhead - rtail
+       movapd	 %xmm10,r(%rsp)
+
+#       subpd	%xmm10,%xmm6						; rr=rhead-r
+#       subpd	xmm6, xmm8						; rr=(rhead-r) -rtail
+#       movapd	OWORD PTR rr[rsp], xmm6
+
+
+# Work on next two args, third arg < 5e5, fourth arg >= 5e5
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lfirst_second_done_fourth_arg_gt_5e5:
+
+# Upper Arg is >= 5e5, Lower arg is < 5e5
+# %r9,%r8
+# %xmm3,,%xmm1 xmm7 = x, xmm4 = 0.5
+
+	movhpd	 %xmm1,r1+8(%rsp)	#Save upper fp arg for remainder_piby2 call
+
+# Work on Lower arg
+# Upper arg might contain nan/inf, to avoid exception use only scalar instructions on lower arg
+	movapd	.L__real_3fe0000000000000(%rip),%xmm4		# Restore 0.5
+	mulsd	.L__real_3fe45f306dc9c883(%rip),%xmm3		# x*twobypi
+	addsd	%xmm4,%xmm3					# xmm3 = npi2=(x*twobypi+0.5)
+	movsd	.L__real_3ff921fb54400000(%rip),%xmm2		# xmm2 = piby2_1
+	cvttsd2si	%xmm3,%r8d				# r8d = npi2 trunc to ints
+	movsd	.L__real_3dd0b4611a600000(%rip),%xmm10		# xmm10 = piby2_2
+	cvtsi2sd	%r8d,%xmm3				# xmm3 = npi2 trunc to doubles
+
+#/* Subtract the multiple from x to get an extra-precision remainder */
+#rhead  = x - npi2 * piby2_1;
+	mulsd	%xmm3,%xmm2					# npi2 * piby2_1
+	subsd	%xmm2,%xmm7					# xmm7 = rhead =(x-npi2*piby2_1)
+	movsd	.L__real_3ba3198a2e037073(%rip),%xmm6		# xmm6 =piby2_2tail
+
+#t  = rhead;
+       movsd	%xmm7,%xmm5					# xmm5 = t = rhead
+
+#rtail  = npi2 * piby2_2;
+       mulsd	%xmm3,%xmm10					# xmm10 =rtail=(npi2*piby2_2)
+
+#rhead  = t - rtail
+       subsd	%xmm10,%xmm7					# xmm7 =rhead=(t-rtail)
+
+#rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+       mulsd	%xmm3,%xmm6     					# npi2 * piby2_2tail
+       subsd	%xmm7,%xmm5					# t-rhead
+       subsd	%xmm5,%xmm10					# (rtail-(t-rhead))
+       addsd	%xmm6,%xmm10					# rtail=npi2*piby2_2tail+(rtail-(t-rhead));
+
+#r =  rhead - rtail
+#rr = (rhead-r) -rtail
+       mov	 %r8d,region1(%rsp)			# store lower region
+
+#       movsd	%xmm7,%xmm1
+#       subsd	xmm1, xmm10					; xmm10 = r=(rhead-rtail)
+#       subsd	%xmm1,%xmm7					; rr=rhead-r
+#       subsd	xmm7, xmm10					; xmm6 = rr=((rhead-r) -rtail)
+
+        subsd	%xmm10,%xmm7					# xmm10 = r=(rhead-rtail)
+
+#       movlpd	QWORD PTR r1[rsp], xmm1				; store upper r
+#       movlpd	QWORD PTR rr1[rsp], xmm7			; store upper rr
+
+        movlpd	 %xmm7,r1(%rsp)				# store upper r
+
+#Work on Upper arg
+#Note that volatiles will be trashed by the call
+#We do not care since this is the last check
+#We will construct r, rr, region and sign
+	mov		$0x07ff0000000000000,%r11			# is upper arg nan/inf
+	mov		%r11,%r10
+	and		%r9,%r10
+	cmp		%r11,%r10
+	jz		.L__vrs4_sinf_upper_naninf_higher
+
+	lea	 region1+4(%rsp),%rdx			# upper arg is **NOT** nan/inf
+	lea	 r1+8(%rsp),%rsi
+
+# changed input from xmm10 to xmm0
+	mov	 r1+8(%rsp),%rdi
+
+	call	 __remainder_piby2d2f@PLT
+
+	jmp 	0f
+
+.L__vrs4_sinf_upper_naninf_higher:
+	mov	$0x00008000000000000,%r11
+	or	%r11,%r9
+	mov	 %r9,r1+8(%rsp)				# r = x | 0x0008000000000000
+	mov	 %r10d,region1+4(%rsp)			# region =0
+
+.align 16
+0:
+	jmp	.L__vrs4_sinf_reconstruct
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrs4_sinf_reconstruct:
+#Results
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	r(%rsp),%xmm10
+	movapd	r1(%rsp),%xmm1
+
+	mov	region(%rsp),%r8
+	mov	region1(%rsp),%r9
+	mov 	.L__reald_one_zero(%rip),%rdx		#compare value for cossin path
+
+	mov 	%r8,%r10
+	mov 	%r9,%r11
+
+	and	.L__reald_one_one(%rip),%r8		#odd/even region for cos/sin
+	and	.L__reald_one_one(%rip),%r9		#odd/even region for cos/sin
+
+	shr	$1,%r10						#~AB+A~B, A is sign and B is upper bit of region
+	shr	$1,%r11						#~AB+A~B, A is sign and B is upper bit of region
+
+	mov	%r10,%rax
+	mov	%r11,%rcx
+
+	not 	%r12						#ADDED TO CHANGE THE LOGIC
+	not 	%r13						#ADDED TO CHANGE THE LOGIC
+	and	%r12,%r10
+	and	%r13,%r11
+
+	not	%rax
+	not	%rcx
+	not	%r12
+	not	%r13
+	and	%r12,%rax
+	and	%r13,%rcx
+
+	or	%rax,%r10
+	or	%rcx,%r11
+	and	.L__reald_one_one(%rip),%r10				#(~AB+A~B)&1
+	and	.L__reald_one_one(%rip),%r11				#(~AB+A~B)&1
+
+	mov	%r10,%r12
+	mov	%r11,%r13
+
+	and	%rdx,%r12				#mask out the lower sign bit leaving the upper sign bit
+	and	%rdx,%r13				#mask out the lower sign bit leaving the upper sign bit
+
+	shl	$63,%r10				#shift lower sign bit left by 63 bits
+	shl	$63,%r11				#shift lower sign bit left by 63 bits
+	shl	$31,%r12				#shift upper sign bit left by 31 bits
+	shl	$31,%r13				#shift upper sign bit left by 31 bits
+
+	mov 	 %r10,p_sign(%rsp)		#write out lower sign bit
+	mov 	 %r12,p_sign+8(%rsp)		#write out upper sign bit
+	mov 	 %r11,p_sign1(%rsp)		#write out lower sign bit
+	mov 	 %r13,p_sign1+8(%rsp)		#write out upper sign bit
+
+	mov	%r8,%rax
+	mov	%r9,%rcx
+
+	movapd	%xmm10,%xmm2
+	movapd	%xmm1,%xmm3
+
+	mulpd	%xmm10,%xmm2				# r2
+	mulpd	%xmm1,%xmm3				# r2
+
+	and	.L__reald_zero_one(%rip),%rax
+	and	.L__reald_zero_one(%rip),%rcx
+	shr	$31,%r8
+	shr	$31,%r9
+	or	%r8,%rax
+	or	%r9,%rcx
+	shl	$2,%rcx
+	or	%rcx,%rax
+
+
+	lea	.Levensin_oddcos_tbl(%rip),%rcx
+	jmp	*(%rcx,%rax,8)				#Jmp table for cos/sin calculation based on even/odd region
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.L__vrsa_sinf_cleanup:
+
+	movapd	  p_sign(%rsp),%xmm10
+	movapd	  p_sign1(%rsp),%xmm1
+
+	xorpd	%xmm4,%xmm10			# (+) Sign
+	xorpd	%xmm5,%xmm1			# (+) Sign
+
+	cvtpd2ps %xmm10,%xmm0
+	cvtpd2ps %xmm1,%xmm11
+	movlhps	 %xmm11,%xmm0
+
+# NEW
+
+.L__vrsa_bottom1:
+# store the result _m128d
+	mov	 save_ya(%rsp),%rdi		# get y_array pointer
+	movlps	 %xmm0,(%rdi)
+	movhps	 %xmm0,8(%rdi)
+
+	prefetch	32(%rdi)
+	add		$16,%rdi
+	mov		%rdi,save_ya(%rsp)	# save y_array pointer
+
+	mov	p_iter(%rsp),%rax	# get number of iterations
+	sub	$1,%rax
+	mov	%rax,p_iter(%rsp)	# save number of iterations
+	jnz	.L__vrsa_top
+
+# see if we need to do any extras
+	mov	save_nv(%rsp),%rax	# get number of values
+	test	%rax,%rax
+	jnz	.L__vrsa_cleanup
+
+.L__final_check:
+
+# NEW
+
+	mov	save_r12(%rsp),%r12	# restore r12
+	mov	save_r13(%rsp),%r13	# restore r13
+
+	add	$0x0228,%rsp
+	ret
+
+#NEW
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# we jump here when we have an odd number of cos calls to make at the end
+# we assume that rdx is pointing at the next x array element, r8 at the next y array element.
+# The number of values left is in save_nv
+
+.align	16
+.L__vrsa_cleanup:
+        mov             save_nv(%rsp),%rax      # get number of values
+        test            %rax,%rax               # are there any values
+        jz              .L__final_check         # exit if not
+
+	mov		save_xa(%rsp),%rsi
+	mov		save_ya(%rsp),%rdi
+
+
+# START WORKING FROM HERE
+# fill in a m128d with zeroes and the extra values and then make a recursive call.
+	xorps		 %xmm0,%xmm0
+	movss		 %xmm0,p_temp+4(%rsp)
+	movlps		 %xmm0,p_temp+8(%rsp)
+
+
+	mov		 (%rsi),%ecx			# we know there's at least one
+	mov	 	 %ecx,p_temp(%rsp)
+	cmp		 $2,%rax
+	jl		 .L__vrsacg
+
+	mov		 4(%rsi),%ecx			# do the second value
+	mov	 	 %ecx,p_temp+4(%rsp)
+	cmp		 $3,%rax
+	jl		 .L__vrsacg
+
+	mov		 8(%rsi),%ecx			# do the third value
+	mov	 	 %ecx,p_temp+8(%rsp)
+
+.L__vrsacg:
+	mov		 $4,%rdi			# parameter for N
+	lea		 p_temp(%rsp),%rsi		# &x parameter
+	lea		 p_temp2(%rsp),%rdx 		# &y parameter
+	call		 vrsa_sinf@PLT			# call recursively to compute four values
+
+# now copy the results to the destination array
+	mov		 save_ya(%rsp),%rdi
+	mov		 save_nv(%rsp),%rax		# get number of values
+
+	mov	 	 p_temp2(%rsp),%ecx
+	mov		 %ecx,(%rdi)			# we know there's at least one
+	cmp		 $2,%rax
+	jl		 .L__vrsacgf
+
+	mov	 	 p_temp2+4(%rsp),%ecx
+	mov		 %ecx,4(%rdi)			# do the second value
+	cmp		 $3,%rax
+	jl		 .L__vrsacgf
+
+	mov	 	 p_temp2+8(%rsp),%ecx
+	mov		 %ecx,8(%rdi)			# do the third value
+
+.L__vrsacgf:
+	jmp		.L__final_check
+
+#NEW
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;JUMP TABLE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcoscos_coscos_piby4:
+	movapd	%xmm2,%xmm0					# r
+	movapd	%xmm3,%xmm11					# r
+
+	movdqa	.Lcosarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lcosarray+0x30(%rip),%xmm5			# c4
+
+	movapd	.Lcosarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lcosarray+0x10(%rip),%xmm9			# c2
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm0	# r = 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11	# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+
+	mulpd	%xmm2,%xmm8					# c3*x2
+	mulpd	%xmm3,%xmm9					# c3*x2
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm0		# -t=r-1.0	;trash r
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0	;trash r
+
+	mulpd	%xmm2,%xmm2					# x4
+	mulpd	%xmm3,%xmm3					# x4
+
+	addpd	.Lcosarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lcosarray+0x20(%rip),%xmm5			# c3+x2c4
+
+	addpd	.Lcosarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lcosarray(%rip),%xmm9			# c1+x2c2
+
+	mulpd	%xmm2,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm3,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm2,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x4 * zc
+
+	subpd   %xmm0,%xmm4					# + t
+	subpd   %xmm11,%xmm5					# + t
+
+	jmp 	.L__vrsa_sinf_cleanup
+
+.align 16
+.Lcossin_cossin_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movdqa	.Lsincosarray+0x30(%rip),%xmm4		# s4
+	movdqa	.Lsincosarray+0x30(%rip),%xmm5		# s4
+	movapd	.Lsincosarray+0x10(%rip),%xmm8		# s2
+	movapd	.Lsincosarray+0x10(%rip),%xmm9		# s2
+
+	movapd	%xmm2,%xmm0				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+
+	mulpd	%xmm2,%xmm4				# x2s4
+	mulpd	%xmm3,%xmm5				# x2s4
+	mulpd	%xmm2,%xmm8				# x2s2
+	mulpd	%xmm3,%xmm9				# x2s2
+
+	mulpd	%xmm2,%xmm0				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lsincosarray+0x20(%rip),%xmm4		# s4+x2s3
+	addpd	.Lsincosarray+0x20(%rip),%xmm5		# s4+x2s3
+	addpd	.Lsincosarray(%rip),%xmm8		# s2+x2s1
+	addpd	.Lsincosarray(%rip),%xmm9		# s2+x2s1
+
+	mulpd	%xmm0,%xmm4				# x4(s3+x2s4)
+	mulpd	%xmm11,%xmm5				# x4(s3+x2s4)
+
+	movhlps	%xmm0,%xmm0				# move high x4 for cos term
+	movhlps	%xmm11,%xmm11				# move high x4 for cos term
+
+	movsd	%xmm2,%xmm6				# move low x2 for x3 for sin term
+	movsd	%xmm3,%xmm7				# move low x2 for x3 for sin term
+	mulsd	%xmm10,%xmm6				# get low x3 for sin term
+	mulsd	%xmm1,%xmm7				# get low x3 for sin term
+
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for sin and cos terms
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for sin and cos terms
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm2,%xmm12				# move high r for cos
+	movhlps	%xmm3,%xmm13				# move high r for cos
+
+	movhlps	%xmm4,%xmm8				# xmm4 = sin , xmm8 = cos
+	movhlps	%xmm5,%xmm9				# xmm4 = sin , xmm8 = cos
+
+	mulsd	%xmm6,%xmm4				# sin *x3
+	mulsd	%xmm7,%xmm5				# sin *x3
+
+	mulsd	%xmm0,%xmm8				# cos *x4
+	mulsd	%xmm11,%xmm9				# cos *x4
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12 	#-t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm13 	#-t=r-1.0
+
+	addsd	%xmm10,%xmm4				# sin + x
+	addsd	%xmm1,%xmm5				# sin + x
+	subsd   %xmm12,%xmm8				# cos+t
+	subsd   %xmm13,%xmm9				# cos+t
+
+	movlhps	%xmm8,%xmm4
+	movlhps	%xmm9,%xmm5
+
+	jmp 	.L__vrsa_sinf_cleanup
+.align 16
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.Lsincos_cossin_piby4:
+
+	movapd	.Lsincosarray+0x30(%rip),%xmm4		# s4
+	movapd	.Lcossinarray+0x30(%rip),%xmm5		# s4
+	movdqa	.Lsincosarray+0x10(%rip),%xmm8		# s2
+	movdqa	.Lcossinarray+0x10(%rip),%xmm9		# s2
+
+	movapd	%xmm2,%xmm0				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+	movapd	%xmm3,%xmm7				# sincos term upper x2 for x3
+
+	mulpd	%xmm2,%xmm4				# x2s4
+	mulpd	%xmm3,%xmm5				# x2s4
+	mulpd	%xmm2,%xmm8				# x2s2
+	mulpd	%xmm3,%xmm9				# x2s2
+
+	mulpd	%xmm2,%xmm0				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lsincosarray+0x20(%rip),%xmm4		# s3+x2s4
+	addpd	.Lcossinarray+0x20(%rip),%xmm5		# s3+x2s4
+	addpd	.Lsincosarray(%rip),%xmm8		# s1+x2s2
+	addpd	.Lcossinarray(%rip),%xmm9		# s1+x2s2
+
+	mulpd	%xmm0,%xmm4				# x4(s3+x2s4)
+	mulpd	%xmm11,%xmm5				# x4(s3+x2s4)
+
+	movhlps	%xmm0,%xmm0				# move high x4 for cos term
+
+	movsd	%xmm2,%xmm6				# move low x2 for x3 for sin term  (cossin)
+	mulpd	%xmm1,%xmm7
+
+	mulsd	%xmm10,%xmm6				# get low x3 for sin term (cossin)
+	movhlps	%xmm7,%xmm7				# get high x3 for sin term (sincos)
+
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for cos term
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for cos term
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+
+	movhlps	%xmm2,%xmm12				# move high r for cos (cossin)
+
+
+	movhlps	%xmm4,%xmm8				# xmm8 = cos , xmm4 = sin	(cossin)
+	movhlps	%xmm5,%xmm9				# xmm9 = sin , xmm5 = cos	(sincos)
+
+	mulsd	%xmm6,%xmm4				# sin *x3
+	mulsd	%xmm11,%xmm5				# cos *x4
+	mulsd	%xmm0,%xmm8				# cos *x4
+	mulsd	%xmm7,%xmm9				# sin *x3
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12 	#-t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm3 	# -t=r-1.0
+
+	movhlps	%xmm1,%xmm11				# move high x for x for sin term    (sincos)
+
+	addsd	%xmm10,%xmm4				# sin + x	+
+	addsd	%xmm11,%xmm9				# sin + x	+
+
+	subsd   %xmm12,%xmm8				# cos+t
+	subsd   %xmm3,%xmm5				# cos+t
+
+	movlhps	%xmm8,%xmm4				# cossin
+	movlhps	%xmm9,%xmm5				# sincos
+
+	jmp	.L__vrsa_sinf_cleanup
+
+.align 16
+.Lsincos_sincos_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	.Lcossinarray+0x30(%rip),%xmm4		# s4
+	movapd	.Lcossinarray+0x30(%rip),%xmm5		# s4
+	movdqa	.Lcossinarray+0x10(%rip),%xmm8		# s2
+	movdqa	.Lcossinarray+0x10(%rip),%xmm9		# s2
+
+	movapd	%xmm2,%xmm0				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+	movapd	%xmm2,%xmm6				# move x2 for x4
+	movapd	%xmm3,%xmm7				# move x2 for x4
+
+	mulpd	%xmm2,%xmm4				# x2s6
+	mulpd	%xmm3,%xmm5				# x2s6
+	mulpd	%xmm2,%xmm8				# x2s3
+	mulpd	%xmm3,%xmm9				# x2s3
+
+	mulpd	%xmm2,%xmm0				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lcossinarray+0x20(%rip),%xmm4		# s4+x2s3
+	addpd	.Lcossinarray+0x20(%rip),%xmm5		# s4+x2s3
+	addpd	.Lcossinarray(%rip),%xmm8		# s2+x2s1
+	addpd	.Lcossinarray(%rip),%xmm9		# s2+x2s1
+
+	mulpd	%xmm0,%xmm4				# x4(s4+x2s3)
+	mulpd	%xmm11,%xmm5				# x4(s4+x2s3)
+
+	mulpd	%xmm10,%xmm6				# get low x3 for sin term
+	mulpd	%xmm1,%xmm7				# get low x3 for sin term
+	movhlps	%xmm6,%xmm6				# move low x2 for x3 for sin term
+	movhlps	%xmm7,%xmm7				# move low x2 for x3 for sin term
+
+	mulsd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for cos terms
+	mulsd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for cos terms
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+	movhlps	%xmm4,%xmm12				# xmm8 = sin , xmm4 = cos
+	movhlps	%xmm5,%xmm13				# xmm9 = sin , xmm5 = cos
+
+	mulsd	%xmm6,%xmm12				# sin *x3
+	mulsd	%xmm7,%xmm13				# sin *x3
+	mulsd	%xmm0,%xmm4				# cos *x4
+	mulsd	%xmm11,%xmm5				# cos *x4
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm2 	#-t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm3 	#-t=r-1.0
+
+	movhlps	%xmm10,%xmm0				# move high x for x for sin term
+	movhlps	%xmm1,%xmm11				# move high x for x for sin term
+							# Reverse 10 and 0
+
+	addsd	%xmm0,%xmm12				# sin + x
+	addsd	%xmm11,%xmm13				# sin + x
+
+	subsd   %xmm2,%xmm4				# cos+t
+	subsd   %xmm3,%xmm5				# cos+t
+
+	movlhps	%xmm12,%xmm4
+	movlhps	%xmm13,%xmm5
+	jmp 	.L__vrsa_sinf_cleanup
+
+.align 16
+.Lcossin_sincos_piby4:
+
+	movapd	.Lcossinarray+0x30(%rip),%xmm4		# s4
+	movapd	.Lsincosarray+0x30(%rip),%xmm5		# s4
+	movdqa	.Lcossinarray+0x10(%rip),%xmm8		# s2
+	movdqa	.Lsincosarray+0x10(%rip),%xmm9		# s2
+
+	movapd	%xmm2,%xmm0				# move x2 for x4
+	movapd	%xmm3,%xmm11				# move x2 for x4
+	movapd	%xmm2,%xmm7				# upper x2 for x3 for sin term (sincos)
+
+	mulpd	%xmm2,%xmm4				# x2s4
+	mulpd	%xmm3,%xmm5				# x2s4
+	mulpd	%xmm2,%xmm8				# x2s2
+	mulpd	%xmm3,%xmm9				# x2s2
+
+	mulpd	%xmm2,%xmm0				# x4
+	mulpd	%xmm3,%xmm11				# x4
+
+	addpd	.Lcossinarray+0x20(%rip),%xmm4		# s3+x2s4
+	addpd	.Lsincosarray+0x20(%rip),%xmm5		# s3+x2s4
+	addpd	.Lcossinarray(%rip),%xmm8		# s1+x2s2
+	addpd	.Lsincosarray(%rip),%xmm9		# s1+x2s2
+
+	mulpd	%xmm0,%xmm4				# x4(s3+x2s4)
+	mulpd	%xmm11,%xmm5				# x4(s3+x2s4)
+
+	movhlps	%xmm11,%xmm11				# move high x4 for cos term
+
+	movsd	%xmm3,%xmm6				# move low x2 for x3 for sin term  (cossin)
+	mulpd	%xmm10,%xmm7
+
+	mulsd	%xmm1,%xmm6				# get low x3 for sin term (cossin)
+	movhlps	%xmm7,%xmm7				# get high x3 for sin term (sincos)
+
+	mulsd 	.L__real_3fe0000000000000(%rip),%xmm2	# 0.5*x2 for cos term
+	mulpd 	.L__real_3fe0000000000000(%rip),%xmm3	# 0.5*x2 for cos term
+
+	addpd	%xmm8,%xmm4				# z
+	addpd	%xmm9,%xmm5				# z
+
+
+	movhlps	%xmm3,%xmm12				# move high r for cos (cossin)
+
+
+	movhlps	%xmm4,%xmm8				# xmm8 = sin , xmm4 = cos	(sincos)
+	movhlps	%xmm5,%xmm9				# xmm9 = cos , xmm5 = sin	(cossin)
+
+	mulsd	%xmm0,%xmm4				# cos *x4
+	mulsd	%xmm6,%xmm5				# sin *x3
+	mulsd	%xmm7,%xmm8				# sin *x3
+	mulsd	%xmm11,%xmm9				# cos *x4
+
+	subsd	.L__real_3ff0000000000000(%rip),%xmm2 	# -t=r-1.0
+	subsd	.L__real_3ff0000000000000(%rip),%xmm12 	# -t=r-1.0
+
+	movhlps	%xmm10,%xmm11				# move high x for x for sin term    (sincos)
+
+	subsd	%xmm2,%xmm4				# cos-(-t)
+	subsd	%xmm12,%xmm9				# cos-(-t)
+
+	addsd   %xmm11,%xmm8				# sin + x
+	addsd   %xmm1,%xmm5				# sin + x
+
+	movlhps	%xmm8,%xmm4				# cossin
+	movlhps	%xmm9,%xmm5				# sincos
+
+	jmp	.L__vrsa_sinf_cleanup
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcoscos_sinsin_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr: 	SIN
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr:	COS
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	%xmm2,%xmm0					# x2	; SIN
+	movapd	%xmm3,%xmm11					# x2	; COS
+	movapd	%xmm3,%xmm1					# copy of x2 for x4
+
+	movdqa	.Lsinarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lcosarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lsinarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lcosarray+0x10(%rip),%xmm9			# c2
+
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	mulpd	%xmm2,%xmm0					# x4
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11		# -t=r-1.0
+	mulpd	%xmm3,%xmm1					# x4
+
+	addpd	.Lsinarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lcosarray+0x20(%rip),%xmm5			# c3+x2c4
+	addpd	.Lsinarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lcosarray(%rip),%xmm9			# c1+x2c2
+
+	mulpd	%xmm10,%xmm2					# x3
+
+	mulpd	%xmm0,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm1,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm1,%xmm5					# x4 * zc
+
+	addpd	%xmm10,%xmm4					# +x
+	subpd   %xmm11,%xmm5					# +t
+
+	jmp 	.L__vrsa_sinf_cleanup
+
+.align 16
+.Lsinsin_coscos_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr: 	COS
+# p_sign1  = Sign, xmm1  = r, xmm3 = %xmm7,%r2 =rr:	SIN
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+	movapd	%xmm2,%xmm0					# x2	; COS
+	movapd	%xmm3,%xmm11					# x2	; SIN
+	movapd	%xmm2,%xmm10					# copy of x2 for x4
+
+	movdqa	.Lcosarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lsinarray+0x30(%rip),%xmm5			# s4
+	movapd	.Lcosarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lsinarray+0x10(%rip),%xmm9			# s2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# s4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# s2*x2
+
+	mulpd	%xmm2,%xmm10					# x4
+	mulpd	%xmm3,%xmm11					# x4
+
+	addpd	.Lcosarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lsinarray+0x20(%rip),%xmm5			# s3+x2c4
+	addpd	.Lcosarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lsinarray(%rip),%xmm9			# s1+x2c2
+
+	mulpd	%xmm1,%xmm3					# x3
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+
+	mulpd	%xmm10,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm11,%xmm5					# x4(s3+x2s4)
+
+	subpd	.L__real_3ff0000000000000(%rip),%xmm0		# -t=r-1.0
+	addpd	%xmm8,%xmm4					# zc
+	addpd	%xmm9,%xmm5					# zs
+
+	mulpd	%xmm10,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# x3 * zc
+
+	subpd	%xmm0,%xmm4					# +t
+	addpd   %xmm1,%xmm5					# +x
+
+	jmp 	.L__vrsa_sinf_cleanup
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+.align 16
+.Lcoscos_cossin_piby4:				#Derive from cossin_coscos
+	movhlps	%xmm2,%xmm0					# x2 for 0.5x2 for upper cos
+	movsd	%xmm2,%xmm6					# lower x2 for x3 for lower sin
+	movapd	%xmm3,%xmm11					# x2 for 0.5x2
+	movapd	%xmm2,%xmm12					# x2 for x4
+	movapd	%xmm3,%xmm13					# x2 for x4
+
+	movsd	.L__real_3ff0000000000000(%rip),%xmm7
+
+	movdqa	.Lsincosarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lcosarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lsincosarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lcosarray+0x10(%rip),%xmm9			# c2
+
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0	# 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11	# 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	subsd	%xmm0,%xmm7					#  t=1.0-r  for cos
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lsincosarray+0x20(%rip),%xmm4			# c4+x2c3
+	addpd	.Lcosarray+0x20(%rip),%xmm5			# c4+x2c3
+	addpd	.Lsincosarray(%rip),%xmm8			# c2+x2c1
+	addpd	.Lcosarray(%rip),%xmm9			# c2+x2c1
+
+
+	movapd	%xmm12,%xmm2					# upper=x4
+	movsd	%xmm6,%xmm2					# lower=x2
+	mulsd	%xmm10,%xmm2					# lower=x2*x
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm2,%xmm4					# upper= x4 * zc
+								# lower=x3 * zs
+	mulpd	%xmm13,%xmm5					# x4 * zc
+
+
+	movlhps	%xmm7,%xmm10					#
+	addpd	%xmm10,%xmm4					# +x for lower sin, +t for upper cos
+	subpd   %xmm11,%xmm5					# -(-t)
+
+	jmp 	.L__vrsa_sinf_cleanup
+.align 16
+.Lcoscos_sincos_piby4:				#Derive from cossin_coscos
+	movsd	%xmm2,%xmm0					# x2 for 0.5x2 for lower cos
+	movapd	%xmm3,%xmm11					# x2 for 0.5x2
+	movapd	%xmm2,%xmm12					# x2 for x4
+	movapd	%xmm3,%xmm13					# x2 for x4
+	movsd	.L__real_3ff0000000000000(%rip),%xmm7
+
+	movdqa	.Lcossinarray+0x30(%rip),%xmm4			# cs4
+	movdqa	.Lcosarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lcossinarray+0x10(%rip),%xmm8			# cs2
+	movapd	.Lcosarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	subsd	%xmm0,%xmm7					# t=1.0-r  for cos
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11		# -t=r-1.0
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lcossinarray+0x20(%rip),%xmm4			# c4+x2c3
+	addpd	.Lcosarray+0x20(%rip),%xmm5			# c4+x2c3
+	addpd	.Lcossinarray(%rip),%xmm8			# c2+x2c1
+	addpd	.Lcosarray(%rip),%xmm9				# c2+x2c1
+
+	mulpd	%xmm10,%xmm2					# upper=x3 for sin
+	mulsd	%xmm10,%xmm2					# lower=x4 for cos
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm2,%xmm4					# lower= x4 * zc
+								# upper= x3 * zs
+	mulpd	%xmm13,%xmm5					# x4 * zc
+
+
+	movsd	%xmm7,%xmm10
+	addpd	%xmm10,%xmm4					# +x for upper sin, +t for lower cos
+	subpd   %xmm11,%xmm5					# -(-t)
+
+	jmp 	.L__vrsa_sinf_cleanup
+.align 16
+.Lcossin_coscos_piby4:
+	movhlps	%xmm3,%xmm0					# x2 for 0.5x2 for upper cos
+	movapd	%xmm2,%xmm11					# x2 for 0.5x2
+	movapd	%xmm2,%xmm12					# x2 for x4
+	movapd	%xmm3,%xmm13					# x2 for x4
+	movsd	%xmm3,%xmm6					# lower x2 for x3 for sin
+	movsd	.L__real_3ff0000000000000(%rip),%xmm7
+
+	movdqa	.Lcosarray+0x30(%rip),%xmm4			# cs4
+	movdqa	.Lsincosarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lcosarray+0x10(%rip),%xmm8			# cs2
+	movapd	.Lsincosarray+0x10(%rip),%xmm9			# c2
+
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11		# 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	subsd	%xmm0,%xmm7					# t=1.0-r  for cos
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11		# -t=r-1.0
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lcosarray+0x20(%rip),%xmm4			# c4+x2c3
+	addpd	.Lsincosarray+0x20(%rip),%xmm5			# c4+x2c3
+	addpd	.Lcosarray(%rip),%xmm8			# c2+x2c1
+	addpd	.Lsincosarray(%rip),%xmm9			# c2+x2c1
+
+	movapd	%xmm13,%xmm3					# upper=x4
+	movsd	%xmm6,%xmm3					# lower x2
+	mulsd	%xmm1,%xmm3					# lower x2*x
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm12,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# upper= x4 * zc
+								# lower=x3 * zs
+
+	movlhps	%xmm7,%xmm1
+	addpd	%xmm1,%xmm5					# +x for lower sin, +t for upper cos
+	subpd   %xmm11,%xmm4					# -(-t)
+
+	jmp 	.L__vrsa_sinf_cleanup
+
+.align 16
+.Lcossin_sinsin_piby4:		# Derived from sincos_coscos
+
+	movhlps	%xmm3,%xmm0					# x2
+	movapd	%xmm3,%xmm7
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+	movsd	.L__real_3ff0000000000000(%rip),%xmm11
+
+	movdqa	.Lsinarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lsincosarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lsinarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lsincosarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	mulpd	%xmm2,%xmm12					# x4
+	subsd	%xmm0,%xmm11					# t=1.0-r for cos
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lsinarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lsincosarray+0x20(%rip),%xmm5			# c3+x2c4
+	addpd	.Lsinarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lsincosarray(%rip),%xmm9			# c1+x2c2
+
+	mulpd	%xmm10,%xmm2					# x3
+	movapd	%xmm13,%xmm3					# upper x4 for cos
+	movsd	%xmm7,%xmm3					# lower x2 for sin
+	mulsd	%xmm1,%xmm3					# lower x3=x2*x for sin
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	movlhps	%xmm11,%xmm1					# t for upper cos and x for lower sin
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zs
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm3,%xmm5					# upper=x4 * zc
+								# lower=x3 * zs
+
+	addpd   %xmm10,%xmm4					# +x
+	addpd	%xmm1,%xmm5					# +t upper, +x lower
+
+
+	jmp 	.L__vrsa_sinf_cleanup
+.align 16
+.Lsincos_coscos_piby4:
+	movsd	%xmm3,%xmm0					# x2 for 0.5x2 for lower cos
+	movapd	%xmm2,%xmm11					# x2 for 0.5x2
+	movapd	%xmm2,%xmm12					# x2 for x4
+	movapd	%xmm3,%xmm13					# x2 for x4
+	movsd	.L__real_3ff0000000000000(%rip),%xmm7
+
+	movdqa	.Lcosarray+0x30(%rip),%xmm4			# cs4
+	movdqa	.Lcossinarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lcosarray+0x10(%rip),%xmm8			# cs2
+	movapd	.Lcossinarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0	# 0.5 *x2
+	mulpd	.L__real_3fe0000000000000(%rip),%xmm11	# 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	subsd	%xmm0,%xmm7					# t=1.0-r  for cos
+	subpd	.L__real_3ff0000000000000(%rip),%xmm11	# -t=r-1.0
+	mulpd	%xmm2,%xmm12					# x4
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lcosarray+0x20(%rip),%xmm4			# c4+x2c3
+	addpd	.Lcossinarray+0x20(%rip),%xmm5			# c4+x2c3
+	addpd	.Lcosarray(%rip),%xmm8			# c2+x2c1
+	addpd	.Lcossinarray(%rip),%xmm9			# c2+x2c1
+
+	mulpd	%xmm1,%xmm3					# upper=x3 for sin
+	mulsd	%xmm1,%xmm3					# lower=x4 for cos
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zczs
+	addpd	%xmm9,%xmm5					# zc
+
+	mulpd	%xmm12,%xmm4					# x4 * zc
+	mulpd	%xmm3,%xmm5					# lower= x4 * zc
+								# upper= x3 * zs
+
+	movsd	%xmm7,%xmm1
+	subpd   %xmm11,%xmm4					# -(-t)
+	addpd	%xmm1,%xmm5					# +x for upper sin, +t for lower cos
+
+
+	jmp 	.L__vrsa_sinf_cleanup
+
+.align 16
+.Lsincos_sinsin_piby4:		# Derived from sincos_coscos
+
+	movsd	%xmm3,%xmm0					# x2
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+	movsd	.L__real_3ff0000000000000(%rip),%xmm11
+
+	movdqa	.Lsinarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lcossinarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lsinarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lcossinarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	mulpd	%xmm2,%xmm12					# x4
+	subsd	%xmm0,%xmm11					# t=1.0-r for cos
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lsinarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lcossinarray+0x20(%rip),%xmm5			# c3+x2c4
+	addpd	.Lsinarray(%rip),%xmm8				# c1+x2c2
+	addpd	.Lcossinarray(%rip),%xmm9			# c1+x2c2
+
+	mulpd	%xmm10,%xmm2					# x3
+	mulpd	%xmm1,%xmm3					# upper x3 for sin
+	mulsd	%xmm1,%xmm3					# lower x4 for cos
+
+	movhlps	%xmm1,%xmm6
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	movlhps	%xmm6,%xmm11					# upper =t ; lower =x
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zszc
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm3,%xmm5					# lower=x4 * zc
+								# upper=x3 * zs
+
+	addpd   %xmm10,%xmm4					# +x
+	addpd	%xmm11,%xmm5					# +t lower, +x upper
+
+	jmp 	.L__vrsa_sinf_cleanup
+
+.align 16
+.Lsinsin_cossin_piby4:		# Derived from sincos_coscos
+
+	movhlps	%xmm2,%xmm0					# x2
+	movapd	%xmm2,%xmm7
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+	movsd	.L__real_3ff0000000000000(%rip),%xmm11
+
+	movdqa	.Lsincosarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lsinarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lsincosarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lsinarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	mulpd	%xmm2,%xmm12					# x4
+	subsd	%xmm0,%xmm11					# t=1.0-r for cos
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lsincosarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lsinarray+0x20(%rip),%xmm5			# c3+x2c4
+	addpd	.Lsincosarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lsinarray(%rip),%xmm9			# c1+x2c2
+
+	mulpd	%xmm1,%xmm3					# x3
+	movapd	%xmm12,%xmm2					# upper x4 for cos
+	movsd	%xmm7,%xmm2					# lower x2 for sin
+	mulsd	%xmm10,%xmm2					# lower x3=x2*x for sin
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	movlhps	%xmm11,%xmm10					# t for upper cos and x for lower sin
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zszc
+
+	mulpd	%xmm3,%xmm5					# x3 * zs
+	mulpd	%xmm2,%xmm4					# upper=x4 * zc
+								# lower=x3 * zs
+
+	addpd	%xmm1,%xmm5					# +x
+	addpd   %xmm10,%xmm4					# +t upper, +x lower
+
+	jmp 	.L__vrsa_sinf_cleanup
+
+.align 16
+.Lsinsin_sincos_piby4:		# Derived from sincos_coscos
+
+	movsd	%xmm2,%xmm0					# x2
+	movapd	%xmm2,%xmm12					# copy of x2 for x4
+	movapd	%xmm3,%xmm13					# copy of x2 for x4
+	movsd	.L__real_3ff0000000000000(%rip),%xmm11
+
+	movdqa	.Lcossinarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lsinarray+0x30(%rip),%xmm5			# c4
+	movapd	.Lcossinarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lsinarray+0x10(%rip),%xmm9			# c2
+
+	mulsd	.L__real_3fe0000000000000(%rip),%xmm0		# r = 0.5 *x2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	mulpd	%xmm2,%xmm12					# x4
+	subsd	%xmm0,%xmm11					# t=1.0-r for cos
+	mulpd	%xmm3,%xmm13					# x4
+
+	addpd	.Lcossinarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lsinarray+0x20(%rip),%xmm5			# c3+x2c4
+	addpd	.Lcossinarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lsinarray(%rip),%xmm9			# c1+x2c2
+
+	mulpd	%xmm1,%xmm3					# x3
+	mulpd	%xmm10,%xmm2					# upper x3 for sin
+	mulsd	%xmm10,%xmm2					# lower x4 for cos
+
+	movhlps	%xmm10,%xmm6
+
+	mulpd	%xmm12,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm13,%xmm5					# x4(c3+x2c4)
+
+	movlhps	%xmm6,%xmm11
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zszc
+
+	mulpd	%xmm3,%xmm5					# x3 * zs
+	mulpd	%xmm2,%xmm4					# lower=x4 * zc
+								# upper=x3 * zs
+
+	addpd	%xmm1,%xmm5					# +x
+	addpd   %xmm11,%xmm4					# +t lower, +x upper
+
+	jmp 	.L__vrsa_sinf_cleanup
+
+.align 16
+.Lsinsin_sinsin_piby4:
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+# p_sign0  = Sign, xmm10 = r, xmm2 = %xmm6,%r2 =rr
+# p_sign1  = Sign, xmm1 = r, xmm3 = %xmm7,%r2 =rr
+#;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+  #x2 = x * x;
+  #(x + x * x2 * (c1 + x2 * (c2 + x2 * (c3 + x2 * c4))));
+
+  #x + x3 * ((c1 + x2 *c2) + x4 * (c3 + x2 * c4));
+
+
+	movapd	%xmm2,%xmm0					# x2
+	movapd	%xmm3,%xmm11					# x2
+
+	movdqa	.Lsinarray+0x30(%rip),%xmm4			# c4
+	movdqa	.Lsinarray+0x30(%rip),%xmm5			# c4
+
+	mulpd	%xmm2,%xmm0					# x4
+	mulpd	%xmm3,%xmm11					# x4
+
+	movapd	.Lsinarray+0x10(%rip),%xmm8			# c2
+	movapd	.Lsinarray+0x10(%rip),%xmm9			# c2
+
+	mulpd	%xmm2,%xmm4					# c4*x2
+	mulpd	%xmm3,%xmm5					# c4*x2
+
+	mulpd	%xmm2,%xmm8					# c2*x2
+	mulpd	%xmm3,%xmm9					# c2*x2
+
+	addpd	.Lsinarray+0x20(%rip),%xmm4			# c3+x2c4
+	addpd	.Lsinarray+0x20(%rip),%xmm5			# c3+x2c4
+
+	mulpd	%xmm10,%xmm2					# x3
+	mulpd	%xmm1,%xmm3					# x3
+
+	addpd	.Lsinarray(%rip),%xmm8			# c1+x2c2
+	addpd	.Lsinarray(%rip),%xmm9			# c1+x2c2
+
+	mulpd	%xmm0,%xmm4					# x4(c3+x2c4)
+	mulpd	%xmm11,%xmm5					# x4(c3+x2c4)
+
+	addpd	%xmm8,%xmm4					# zs
+	addpd	%xmm9,%xmm5					# zs
+
+	mulpd	%xmm2,%xmm4					# x3 * zs
+	mulpd	%xmm3,%xmm5					# x3 * zs
+
+	addpd	%xmm10,%xmm4					# +x
+	addpd	%xmm1,%xmm5					# +x
+
+	jmp 	.L__vrsa_sinf_cleanup
diff --git a/src/hypot.c b/src/hypot.c
new file mode 100644
index 0000000..063d526
--- /dev/null
+++ b/src/hypot.c
@@ -0,0 +1,223 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#define USE_SCALEDOUBLE_1
+#define USE_INFINITY_WITH_FLAGS
+#define USE_HANDLE_ERROR
+#include "../inc/libm_inlines_amd.h"
+#undef USE_SCALEDOUBLE_1
+#undef USE_INFINITY_WITH_FLAGS
+#undef USE_HANDLE_ERROR
+
+#include "../inc/libm_errno_amd.h"
+
+#ifndef WINDOWS
+/* Deal with errno for out-of-range result */
+static inline double retval_errno_erange_overflow(double x, double y)
+{
+  struct exception exc;
+  exc.arg1 = x;
+  exc.arg2 = y;
+  exc.type = OVERFLOW;
+  exc.name = (char *)"hypot";
+  if (_LIB_VERSION == _SVID_)
+    exc.retval = HUGE;
+  else
+    exc.retval = infinity_with_flags(AMD_F_OVERFLOW | AMD_F_INEXACT);
+  if (_LIB_VERSION == _POSIX_)
+    __set_errno(ERANGE);
+  else if (!matherr(&exc))
+    __set_errno(ERANGE);
+  return exc.retval;
+}
+#endif
+
+#ifdef WINDOWS
+double FN_PROTOTYPE(hypot)(double x, double y)
+#else
+double FN_PROTOTYPE(hypot)(double x, double y)
+#endif
+{
+  /* Returns sqrt(x*x + y*y) with no overflow or underflow unless
+     the result warrants it */
+
+  const double large = 1.79769313486231570815e+308; /* 0x7fefffffffffffff */
+
+  double u, r, retval, hx, tx, x2, hy, ty, y2, hs, ts;
+  unsigned long long xexp, yexp, ux, uy, ut;
+  int dexp, expadjust;
+
+  GET_BITS_DP64(x, ux);
+  ux &= ~SIGNBIT_DP64;
+  GET_BITS_DP64(y, uy);
+  uy &= ~SIGNBIT_DP64;
+  xexp = (ux >> EXPSHIFTBITS_DP64);
+  yexp = (uy >> EXPSHIFTBITS_DP64);
+
+  if (xexp == BIASEDEMAX_DP64 + 1 || yexp == BIASEDEMAX_DP64 + 1)
+    {
+      /* One or both of the arguments are NaN or infinity. The
+         result will also be NaN or infinity. */
+      retval = x*x + y*y;
+      if (((xexp == BIASEDEMAX_DP64 + 1) && !(ux & MANTBITS_DP64)) ||
+          ((yexp == BIASEDEMAX_DP64 + 1) && !(uy & MANTBITS_DP64)))
+        /* x or y is infinity. ISO C99 defines that we must
+           return +infinity, even if the other argument is NaN.
+           Note that the computation of x*x + y*y above will already
+           have raised invalid if either x or y is a signalling NaN. */
+        return infinity_with_flags(0);
+      else
+        /* One or both of x or y is NaN, and neither is infinity.
+           Raise invalid if it's a signalling NaN */
+        return retval;
+    }
+
+  /* Set x = abs(x) and y = abs(y) */
+  PUT_BITS_DP64(ux, x);
+  PUT_BITS_DP64(uy, y);
+
+  /* The difference in exponents between x and y */
+  dexp = (int)(xexp - yexp);
+  expadjust = 0;
+
+  if (ux == 0)
+    /* x is zero */
+    return y;
+  else if (uy == 0)
+    /* y is zero */
+    return x;
+  else if (dexp > MANTLENGTH_DP64 + 1 || dexp < -MANTLENGTH_DP64 - 1)
+    /* One of x and y is insignificant compared to the other */
+    return x + y; /* Raise inexact */
+  else if (xexp > EXPBIAS_DP64 + 500 || yexp > EXPBIAS_DP64 + 500)
+    {
+      /* Danger of overflow; scale down by 2**600. */
+      expadjust = 600;
+      ux -= 0x2580000000000000;
+      PUT_BITS_DP64(ux, x);
+      uy -= 0x2580000000000000;
+      PUT_BITS_DP64(uy, y);
+    }
+  else if (xexp < EXPBIAS_DP64 - 500 || yexp < EXPBIAS_DP64 - 500)
+    {
+      /* Danger of underflow; scale up by 2**600. */
+      expadjust = -600;
+      if (xexp == 0)
+        {
+          /* x is denormal - handle by adding 601 to the exponent
+           and then subtracting a correction for the implicit bit */
+          PUT_BITS_DP64(ux + 0x2590000000000000, x);
+          x -= 9.23297861778573578076e-128; /* 0x2590000000000000 */
+          GET_BITS_DP64(x, ux);
+        }
+      else
+        {
+          /* x is normal - just increase the exponent by 600 */
+          ux += 0x2580000000000000;
+          PUT_BITS_DP64(ux, x);
+        }
+      if (yexp == 0)
+        {
+          PUT_BITS_DP64(uy + 0x2590000000000000, y);
+          y -= 9.23297861778573578076e-128; /* 0x2590000000000000 */
+          GET_BITS_DP64(y, uy);
+        }
+      else
+        {
+          uy += 0x2580000000000000;
+          PUT_BITS_DP64(uy, y);
+        }
+    }
+
+
+#ifdef FAST_BUT_GREATER_THAN_ONE_ULP
+  /* Not awful, but results in accuracy loss larger than 1 ulp */
+  r = x*x + y*y
+#else
+  /* Slower but more accurate */
+
+  /* Sort so that x is greater than y */
+  if (x < y)
+    {
+      u = y;
+      y = x;
+      x = u;
+      ut = ux;
+      ux = uy;
+      uy = ut;
+    }
+
+  /* Split x into hx and tx, head and tail */
+  PUT_BITS_DP64(ux & 0xfffffffff8000000, hx);
+  tx = x - hx;
+
+  PUT_BITS_DP64(uy & 0xfffffffff8000000, hy);
+  ty = y - hy;
+
+  /* Compute r = x*x + y*y with extra precision */
+  x2 = x*x;
+  y2 = y*y;
+  hs = x2 + y2;
+
+  if (dexp == 0)
+    /* We take most care when x and y have equal exponents,
+       i.e. are almost the same size */
+    ts = (((x2 - hs) + y2) +
+          ((hx * hx - x2) + 2 * hx * tx) + tx * tx) +
+      ((hy * hy - y2) + 2 * hy * ty) + ty * ty;
+  else
+    ts = (((x2 - hs) + y2) +
+          ((hx * hx - x2) + 2 * hx * tx) + tx * tx);
+
+  r = hs + ts;
+#endif
+
+  /* The sqrt can introduce another half ulp error. */
+#ifdef WINDOWS
+  /* VC++ intrinsic call */
+  _mm_store_sd(&retval, _mm_sqrt_sd(_mm_setzero_pd(), _mm_load_sd(&r)));
+#else
+  /* Hammer sqrt instruction */
+  asm volatile ("sqrtsd %1, %0" : "=x" (retval) : "x" (r));
+#endif
+
+  /* If necessary scale the result back. This may lead to
+     overflow but if so that's the correct result. */
+  retval = scaleDouble_1(retval, expadjust);
+
+  if (retval > large)
+    /* The result overflowed. Deal with errno. */
+#ifdef WINDOWS
+    return handle_error("hypot", PINFBITPATT_DP64, _OVERFLOW,
+                        AMD_F_OVERFLOW | AMD_F_INEXACT, ERANGE, x, y);
+#else
+    return retval_errno_erange_overflow(x, y);
+#endif
+
+  return retval;
+}
+
+weak_alias (__hypot, hypot)
diff --git a/src/hypotf.c b/src/hypotf.c
new file mode 100644
index 0000000..fcc09fc
--- /dev/null
+++ b/src/hypotf.c
@@ -0,0 +1,131 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#ifdef USE_SOFTWARE_SQRT
+#define USE_SQRTF_AMD_INLINE
+#endif
+#define USE_INFINITYF_WITH_FLAGS
+#define USE_HANDLE_ERRORF
+#include "../inc/libm_inlines_amd.h"
+#ifdef USE_SOFTWARE_SQRT
+#undef USE_SQRTF_AMD_INLINE
+#endif
+#undef USE_INFINITYF_WITH_FLAGS
+#undef USE_HANDLE_ERRORF
+
+#include "../inc/libm_errno_amd.h"
+
+#ifndef WINDOWS
+/* Deal with errno for out-of-range result */
+static inline float retval_errno_erange_overflow(float x, float y)
+{
+  struct exception exc;
+  exc.arg1 = (double)x;
+  exc.arg2 = (double)y;
+  exc.type = OVERFLOW;
+  exc.name = (char *)"hypotf";
+  if (_LIB_VERSION == _SVID_)
+    exc.retval = HUGE;
+  else
+    exc.retval = infinityf_with_flags(AMD_F_OVERFLOW | AMD_F_INEXACT);
+  if (_LIB_VERSION == _POSIX_)
+    __set_errno(ERANGE);
+  else if (!matherr(&exc))
+    __set_errno(ERANGE);
+  return exc.retval;
+}
+#endif
+
+#ifdef WINDOWS
+float FN_PROTOTYPE(hypotf)(float x, float y)
+#else
+float FN_PROTOTYPE(hypotf)(float x, float y)
+#endif
+{
+  /* Returns sqrt(x*x + y*y) with no overflow or underflow unless
+     the result warrants it */
+
+    /* Do intermediate computations in double precision
+       and use sqrt instruction from chip if available. */
+    double dx = x, dy = y, dr, retval;
+
+    /* The largest finite float, stored as a double */
+    const double large = 3.40282346638528859812e+38; /* 0x47efffffe0000000 */
+
+
+  unsigned long long ux, uy, avx, avy;
+
+  GET_BITS_DP64(x, avx);
+  avx &= ~SIGNBIT_DP64;
+  GET_BITS_DP64(y, avy);
+  avy &= ~SIGNBIT_DP64;
+  ux = (avx >> EXPSHIFTBITS_DP64);
+  uy = (avy >> EXPSHIFTBITS_DP64);
+
+  if (ux == BIASEDEMAX_DP64 + 1 || uy == BIASEDEMAX_DP64 + 1)
+    {
+      retval = x*x + y*y;
+      /* One or both of the arguments are NaN or infinity. The
+         result will also be NaN or infinity. */
+      if (((ux == BIASEDEMAX_DP64 + 1) && !(avx & MANTBITS_DP64)) ||
+          ((uy == BIASEDEMAX_DP64 + 1) && !(avy & MANTBITS_DP64)))
+        /* x or y is infinity. ISO C99 defines that we must
+           return +infinity, even if the other argument is NaN.
+           Note that the computation of x*x + y*y above will already
+           have raised invalid if either x or y is a signalling NaN. */
+        return infinityf_with_flags(0);
+      else
+        /* One or both of x or y is NaN, and neither is infinity.
+           Raise invalid if it's a signalling NaN */
+        return (float)retval;
+    }
+
+    dr = (dx*dx + dy*dy);
+
+#if USE_SOFTWARE_SQRT
+    retval = sqrtf_amd_inline(r);
+#else
+#ifdef WINDOWS
+  /* VC++ intrinsic call */
+  _mm_store_sd(&retval, _mm_sqrt_sd(_mm_setzero_pd(), _mm_load_sd(&dr)));
+#else
+    /* Hammer sqrt instruction */
+    asm volatile ("sqrtsd %1, %0" : "=x" (retval) : "x" (dr));
+#endif
+#endif
+
+    if (retval > large)
+#ifdef WINDOWS
+      return handle_errorf("hypotf", PINFBITPATT_SP32, _OVERFLOW,
+                           AMD_F_OVERFLOW | AMD_F_INEXACT, ERANGE, x, y);
+#else
+      return retval_errno_erange_overflow(x, y);
+#endif
+    else
+      return (float)retval;
+  }
+
+weak_alias (__hypotf, hypotf)
diff --git a/src/ilogb.c b/src/ilogb.c
new file mode 100644
index 0000000..2c1cb7c
--- /dev/null
+++ b/src/ilogb.c
@@ -0,0 +1,99 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifdef WIN64
+#include <fpieee.h>
+#else
+#include <errno.h>
+#endif
+
+#include <math.h>
+#include <limits.h>
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#include "../inc/libm_special.h"
+
+
+int FN_PROTOTYPE(ilogb)(double x)
+{
+
+
+    /* Check for input range */
+    UT64 checkbits;
+    int expbits;
+    U64 manbits;
+	U64  zerovalue;
+	    /* Clear the sign bit and check if the value is zero nan or inf.*/
+	checkbits.f64=x;
+    zerovalue = (checkbits.u64 & ~SIGNBIT_DP64);
+
+    if(zerovalue == 0)
+    {
+        /* Raise exception as the number zero*/
+		__amd_handle_error(DOMAIN, EDOM, "ilogb", x, 0.0 ,(double)INT_MIN);
+		
+
+         return INT_MIN;
+    }
+
+    if( zerovalue == EXPBITS_DP64 )
+    {
+        /* Raise exception as the number is inf */
+
+		__amd_handle_error(DOMAIN, EDOM, "ilogb", x, 0.0 ,(double)INT_MAX);
+		
+        return INT_MAX;
+    }
+
+    if( zerovalue > EXPBITS_DP64 )
+    {
+		/* Raise exception as the number is nan */
+		__amd_handle_error(DOMAIN, EDOM, "ilogb", x, 0.0 ,(double)INT_MIN);
+		
+
+		return INT_MIN;
+    }
+
+    expbits = (int) (( checkbits.u64 << 1) >> 53);
+
+    if(expbits == 0 && (checkbits.u64 & MANTBITS_DP64 )!= 0)
+    {
+        /* the value is denormalized */
+      manbits = checkbits.u64 & MANTBITS_DP64;
+      expbits = EMIN_DP64;
+      while (manbits < IMPBIT_DP64)
+        {
+          manbits <<= 1;
+          expbits--;
+        }
+    }
+    else
+	{
+
+		expbits-=EXPBIAS_DP64;
+	}
+
+
+    return expbits;
+}
diff --git a/src/ilogbf.c b/src/ilogbf.c
new file mode 100644
index 0000000..cb129e6
--- /dev/null
+++ b/src/ilogbf.c
@@ -0,0 +1,109 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifdef WIN64
+#include <fpieee.h>
+#else
+#include <errno.h>
+#endif
+
+#include <math.h>
+#include <limits.h>
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#include "../inc/libm_special.h"
+
+int FN_PROTOTYPE(ilogbf)(float x)
+{
+
+    /* Check for input range */
+    UT32 checkbits;
+    int expbits;
+    U32 manbits;
+	U32 zerovalue;
+    checkbits.f32=x;
+
+    /* Clear the sign bit and check if the value is zero nan or inf.*/
+    zerovalue = (checkbits.u32 & ~SIGNBIT_SP32);
+
+    if(zerovalue == 0)
+    {
+		/* Raise exception as the number zero*/
+        {
+            unsigned int is_x_snan;
+            UT32 xm; xm.f32 = x;
+            is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+            __amd_handle_errorf(DOMAIN, EDOM, "ilogb", x, is_x_snan, 0.0f, 0, (float) INT_MIN, 0);
+        }
+		
+		return INT_MIN;
+    }
+
+    if( zerovalue == EXPBITS_SP32 )
+    {
+		/* Raise exception as the number is inf */
+        {
+            unsigned int is_x_snan;
+            UT32 xm; xm.f32 = x;
+            is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+            __amd_handle_errorf(DOMAIN, EDOM, "ilogb", x, is_x_snan, 0.0f, 0, (float) INT_MAX, 0);
+        }
+		
+		return INT_MAX;
+    }
+
+    if( zerovalue > EXPBITS_SP32 )
+    {
+		/* Raise exception as the number is nan */
+        {
+            unsigned int is_x_snan;
+            UT32 xm; xm.f32 = x;
+            is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+            __amd_handle_errorf(DOMAIN, EDOM, "ilogb", x, is_x_snan, 0.0f, 0, (float) INT_MIN, 0);
+        }
+        
+		return INT_MIN;
+    }
+
+    expbits = (int) (( checkbits.u32 << 1) >> 24);
+
+    if(expbits == 0 && (checkbits.u32 & MANTBITS_SP32 )!= 0)
+    {
+        /* the value is denormalized */
+      manbits = checkbits.u32 & MANTBITS_SP32;
+      expbits = EMIN_SP32;
+      while (manbits < IMPBIT_SP32)
+        {
+          manbits <<= 1;
+          expbits--;
+        }
+    }
+    else
+	{
+		expbits-=EXPBIAS_SP32;
+	}
+
+
+    return expbits;
+}
diff --git a/src/ldexp.c b/src/ldexp.c
new file mode 100644
index 0000000..695118b
--- /dev/null
+++ b/src/ldexp.c
@@ -0,0 +1,117 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifdef WIN64
+#include <fpieee.h>
+#else
+#include <errno.h>
+#endif
+
+#include <math.h>
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#include "../inc/libm_special.h"
+
+double FN_PROTOTYPE(ldexp)(double x, int n)
+{
+    UT64 val;
+    unsigned int sign;
+    int exponent;
+    val.f64 = x;
+    sign = val.u32[1] & 0x80000000;
+    val.u32[1] = val.u32[1] & 0x7fffffff; /* remove the sign bit */
+
+    if((val.u32[1] & 0x7ff00000)== 0x7ff00000)/* x= nan or x = +-inf*/
+        return x;
+
+    if((val.u64 == 0x0000000000000000) || (n==0))
+        return x; /* x= +-0 or n= 0*/
+
+    exponent = val.u32[1] >> 20; /* get the exponent */
+
+    if(exponent == 0)/*x is denormal*/
+    {
+		val.f64 = val.f64 * VAL_2PMULTIPLIER_DP;/*multiply by 2^53 to bring it to the normal range*/
+        exponent = val.u32[1] >> 20; /* get the exponent */
+		exponent = exponent + n - MULTIPLIER_DP;
+		if(exponent < -MULTIPLIER_DP)/*underflow*/
+		{
+			val.u32[1] = sign | 0x00000000;
+			val.u32[0] = 0x00000000;
+			__amd_handle_error(UNDERFLOW, ERANGE, "ldexp", x,(double)n ,val.f64);
+			
+			return val.f64;
+		}
+		if(exponent > 2046)/*overflow*/
+		{
+			val.u32[1] = sign | 0x7ff00000;
+			val.u32[0] = 0x00000000;
+			__amd_handle_error(OVERFLOW, ERANGE, "ldexp", x,(double)n ,val.f64);
+			
+			return val.f64;
+		}
+
+		exponent += MULTIPLIER_DP;
+		val.u32[1] = sign | (exponent << 20) | (val.u32[1] & 0x000fffff);
+		val.f64 = val.f64 * VAL_2PMMULTIPLIER_DP;
+        return val.f64;
+    }
+
+    exponent += n;
+
+    if(exponent < -MULTIPLIER_DP)/*underflow*/
+	{
+		val.u32[1] = sign | 0x00000000;
+		val.u32[0] = 0x00000000;
+
+		__amd_handle_error(UNDERFLOW, ERANGE, "ldexp", x,(double)n ,val.f64);
+		
+
+		return val.f64;
+	}
+
+    if(exponent < 1)/*x is normal but output is debnormal*/
+    {
+		exponent += MULTIPLIER_DP;
+		val.u32[1] = sign | (exponent << 20) | (val.u32[1] & 0x000fffff);
+		val.f64 = val.f64 * VAL_2PMMULTIPLIER_DP;
+        return val.f64;
+    }
+
+    if(exponent > 2046)/*overflow*/
+	{
+		val.u32[1] = sign | 0x7ff00000;
+		val.u32[0] = 0x00000000;
+		__amd_handle_error(OVERFLOW, ERANGE, "ldexp", x,(double)n ,val.f64);
+		
+
+		return val.f64;
+	}
+
+    val.u32[1] = sign | (exponent << 20) | (val.u32[1] & 0x000fffff);
+    return val.f64;
+}
+
+
+
diff --git a/src/ldexpf.c b/src/ldexpf.c
new file mode 100644
index 0000000..892c6e9
--- /dev/null
+++ b/src/ldexpf.c
@@ -0,0 +1,133 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifdef WIN64
+#include <fpieee.h>
+#endif
+
+#include <math.h>
+#include <errno.h>
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#include "../inc/libm_special.h"
+
+
+float FN_PROTOTYPE(ldexpf)(float x, int n)
+{
+    UT32 val;
+    unsigned int sign;
+    int exponent;
+    val.f32 = x;
+    sign = val.u32 & 0x80000000;
+    val.u32 = val.u32 & 0x7fffffff;/* remove the sign bit */
+
+    if((val.u32 & 0x7f800000)== 0x7f800000)/* x= nan or x = +-inf*/
+        return x;
+
+    if((val.u32 == 0x00000000) || (n==0))/* x= +-0 or n= 0*/
+        return x;
+
+    exponent = val.u32 >> 23; /* get the exponent */
+
+	if(exponent == 0)/*x is denormal*/
+	{
+		val.f32 = val.f32 * VAL_2PMULTIPLIER_SP;/*multiply by 2^24 to bring it to the normal range*/
+		exponent = (val.u32 >> 23); /* get the exponent */
+		exponent = exponent + n - MULTIPLIER_SP;
+		if(exponent < -MULTIPLIER_SP)/*underflow*/
+		{
+			val.u32 = sign | 0x00000000;
+
+            {
+                unsigned int is_x_snan;
+                UT32 xm; xm.f32 = x;
+                is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+                __amd_handle_errorf(UNDERFLOW, ERANGE, "ldexpf", x, is_x_snan, (float)n , 0,val.f32, 0);
+            }
+			
+			return val.f32;
+		}
+		if(exponent > 254)/*overflow*/
+		{
+			val.u32 = sign | 0x7f800000;
+
+            {
+                unsigned int is_x_snan;
+                UT32 xm; xm.f32 = x;
+                is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+                __amd_handle_errorf(OVERFLOW, ERANGE, "ldexpf", x, is_x_snan, (float)n , 0,val.f32, 0);
+            }
+
+			
+			return val.f32;
+		}
+
+		exponent += MULTIPLIER_SP;
+		val.u32 = sign | (exponent << 23) | (val.u32 & 0x007fffff);
+		val.f32 = val.f32 * VAL_2PMMULTIPLIER_SP;
+        return val.f32;
+	}
+
+    exponent += n;
+
+    if(exponent < -MULTIPLIER_SP)/*underflow*/
+	{
+		val.u32 = sign | 0x00000000;
+
+        {
+            unsigned int is_x_snan;
+            UT32 xm; xm.f32 = x;
+            is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+            __amd_handle_errorf(UNDERFLOW, ERANGE, "ldexpf", x, is_x_snan, (float)n , 0,val.f32, 0);
+        }
+
+		return val.f32;
+	}
+
+    if(exponent < 1)/*x is normal but output is debnormal*/
+    {
+		exponent += MULTIPLIER_SP;
+		val.u32 = sign | (exponent << 23) | (val.u32 & 0x007fffff);
+		val.f32 = val.f32 * VAL_2PMMULTIPLIER_SP;
+        return val.f32;
+    }
+
+    if(exponent > 254)/*overflow*/
+	{
+        val.u32 = sign | 0x7f800000;
+
+        {
+            unsigned int is_x_snan;
+            UT32 xm; xm.f32 = x;
+            is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+            __amd_handle_errorf(OVERFLOW, ERANGE, "ldexpf", x, is_x_snan, (float)n , 0,val.f32, 0);
+        }
+
+        return val.f32;
+	}
+
+    val.u32 = sign | (exponent << 23) | (val.u32 & 0x007fffff);/*x is normal and output is normal*/
+    return val.f32;
+}
+
diff --git a/src/libm_special.c b/src/libm_special.c
new file mode 100644
index 0000000..974d99b
--- /dev/null
+++ b/src/libm_special.c
@@ -0,0 +1,117 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+#ifdef __x86_64__
+
+#include <emmintrin.h>
+#include <math.h>
+#include <errno.h>
+
+#include "../inc/libm_util_amd.h"
+#include "../inc/libm_special.h"
+
+#ifdef WIN64
+#define EXCEPTION_S _exception
+#else
+#define EXCEPTION_S exception
+#endif
+
+
+
+static double convert_snan_32to64(float x)
+{
+    U64 t;
+    UT32 xs;
+    UT64 xb;
+    
+    xs.f32 = x;
+    xb.u64 = (((xs.u32 & SIGNBIT_SP32) == SIGNBIT_SP32) ? NINFBITPATT_DP64 : EXPBITS_DP64);
+    
+    t = 0;
+    t = (xs.u32 & MANTBITS_SP32);
+    t = (t << 29); // 29 = (52-23)
+    xb.u64 = (xb.u64 | t);
+
+    return xb.f64;
+}
+
+#ifdef NEED_FAKE_MATHERR
+int
+matherr (struct exception *s)
+{
+  return 0;
+}
+#endif
+
+void __amd_handle_errorf(int type, int error, const char *name,
+                    float arg1, unsigned int arg1_is_snan,
+                    float arg2, unsigned int arg2_is_snan,
+                    float retval, unsigned int retval_is_snan)
+{
+    struct EXCEPTION_S exception_data;
+
+    // write exception info
+    exception_data.type = type;
+    exception_data.name = (char*)name;
+
+    // sNaN float to double conversion can trigger interrupt
+    // handle them specially
+
+    if(arg1_is_snan)    { exception_data.arg1 = convert_snan_32to64(arg1); }
+    else                { exception_data.arg1 = (double)arg1; }
+
+    if(arg2_is_snan)    { exception_data.arg2 = convert_snan_32to64(arg2); }
+    else                { exception_data.arg2 = (double)arg2; }
+
+    if(retval_is_snan)  { exception_data.retval = convert_snan_32to64(retval); }
+    else                { exception_data.retval = (double)retval; }
+
+    // call matherr, set errno if matherr returns 0
+    if(!matherr(&exception_data))
+    {
+        errno = error;
+    }
+}
+
+void __amd_handle_error(int type, int error, const char *name,
+                   double arg1,
+                   double arg2,
+                   double retval)
+{
+    struct EXCEPTION_S exception_data;
+
+    // write exception info
+    exception_data.type = type;
+    exception_data.name = (char*)name;
+
+    exception_data.arg1 = arg1;
+    exception_data.arg2 = arg2;
+    exception_data.retval = retval;
+
+    // call matherr, set errno if matherr returns 0
+    if(!matherr(&exception_data))
+    {
+        errno = error;
+    }
+}
+
+#endif /* __x86_64__ */
diff --git a/src/llrint.c b/src/llrint.c
new file mode 100644
index 0000000..5f96115
--- /dev/null
+++ b/src/llrint.c
@@ -0,0 +1,62 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifdef WIN64
+#include <fpieee.h>
+#else
+#include <errno.h>
+#endif
+
+#include <math.h>
+
+#include "libm_amd.h"
+#include "libm_util_amd.h"
+#include "libm_special.h"
+
+
+long long int FN_PROTOTYPE(llrint)(double x)
+{
+
+
+    UT64 checkbits,val_2p52;
+    checkbits.f64=x;
+
+    /* Clear the sign bit and check if the value can be rounded */
+
+    if( (checkbits.u64 & 0x7FFFFFFFFFFFFFFF) > 0x4330000000000000)
+    {
+        /* number cant be rounded raise an exception */
+        /* Number exceeds the representable range could be nan or inf also*/
+        __amd_handle_error(DOMAIN, EDOM, "llrint", x,0.0 ,(double)x);
+
+	  	return (long long int) x;
+    }
+
+    val_2p52.u32[1] = (checkbits.u32[1] & 0x80000000) | 0x43300000;
+    val_2p52.u32[0] = 0;
+
+
+	/* Add and sub 2^52 to round the number according to the current rounding direction */
+
+    return (long long int) ((x + val_2p52.f64) - val_2p52.f64);
+}
diff --git a/src/llrintf.c b/src/llrintf.c
new file mode 100644
index 0000000..509e46b
--- /dev/null
+++ b/src/llrintf.c
@@ -0,0 +1,67 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifdef WIN64
+#include <fpieee.h>
+#else
+#include <errno.h>
+#endif
+
+#include <math.h>
+
+#include "libm_amd.h"
+#include "libm_util_amd.h"
+#include "libm_special.h"
+
+
+
+long long int FN_PROTOTYPE(llrintf)(float x)
+{
+
+    UT32 checkbits,val_2p23;
+    checkbits.f32=x;
+
+    /* Clear the sign bit and check if the value can be rounded */
+
+    if( (checkbits.u32 & 0x7FFFFFFF) > 0x4B000000)
+    {
+        /* number cant be rounded raise an exception */
+        /* Number exceeds the representable range could be nan or inf also*/
+
+        {
+            unsigned int is_x_snan;
+            UT32 xm; xm.f32 = x;
+            is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+            __amd_handle_errorf(DOMAIN, EDOM, "llrintf", x, is_x_snan, 0.0F , 0,(float)x, 0);
+        }
+
+	    return (long long int) x;
+    }
+
+
+    val_2p23.u32 = (checkbits.u32 & 0x80000000) | 0x4B000000;
+
+   /* Add and sub 2^23 to round the number according to the current rounding direction */
+
+    return (long long int) ((x + val_2p23.f32) - val_2p23.f32);
+}
diff --git a/src/llround.c b/src/llround.c
new file mode 100644
index 0000000..0b582c2
--- /dev/null
+++ b/src/llround.c
@@ -0,0 +1,112 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifdef WIN64
+#include <fpieee.h>
+#else
+#include <errno.h>
+#endif
+
+#include <math.h>
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#include "../inc/libm_special.h"
+
+#ifdef WINDOWS
+/*In windows llong long int is 64 bit and long int is 32 bit.
+  In Linux long long int and long int both are of size 64 bit*/
+long long int FN_PROTOTYPE(llround)(double d)
+{
+    UT64 u64d;
+    UT64 u64Temp,u64result;
+    int intexp, shift;
+    U64 sign;
+    long long int result;
+
+    u64d.f64 = u64Temp.f64 = d;
+
+    if ((u64d.u32[1] & 0X7FF00000) == 0x7FF00000)
+    {
+        /*else the number is infinity*/
+        //Got to raise range or domain error
+            __amd_handle_error(DOMAIN, EDOM, "llround", d, 0.0 , (double)SIGNBIT_DP64);
+			return SIGNBIT_DP64; /*GCC returns this when the number is out of range*/
+    }
+
+    u64Temp.u32[1] &= 0x7FFFFFFF;
+    intexp = (u64d.u32[1] & 0x7FF00000) >> 20;
+    sign = u64d.u64 & 0x8000000000000000;
+    intexp -= 0x3FF;
+
+    /* 1.0 x 2^-1 is the smallest number which can be rounded to 1 */
+    if (intexp < -1)
+        return (0);
+
+    /* 1.0 x 2^31 (or 2^63) is already too large */
+    if (intexp >= 63)
+    {
+        /*Based on the sign of the input value return the MAX and MIN*/
+        result = 0x8000000000000000; /*Return LONG MIN*/
+        __amd_handle_error(DOMAIN, EDOM, "lround", d, 0.0 , (double) result);
+
+        return result;
+    }
+
+    u64result.f64 = u64Temp.f64;
+    /* >= 2^52 is already an exact integer */
+    if (intexp < 52)
+    {
+        /* add 0.5, extraction below will truncate */
+        u64result.f64 = u64Temp.f64 + 0.5;
+    }
+
+    intexp = ((u64result.u32[1] >> 20) & 0x7ff) - 0x3FF;
+
+    u64result.u32[1] &= 0xfffff;
+    u64result.u32[1] |= 0x00100000; /*Mask the last exp bit to 1*/
+    shift = intexp - 52;
+
+    if(shift < 0)
+        u64result.u64 = u64result.u64 >> (-shift);
+    if(shift > 0)
+        u64result.u64 = u64result.u64 << (shift);
+
+    result = u64result.u64;
+
+    if (sign)
+        result = -result;
+
+    return result;
+}
+
+#else //WINDOWS 
+/*llroundf is equivalent to the linux implementation of 
+  lroundf. Both long int and long long int are of the same size*/
+long long int FN_PROTOTYPE(llround)(double d)
+{
+    long long int result;
+    result = FN_PROTOTYPE(lround)(d);
+    return result;
+}
+#endif
diff --git a/src/llroundf.c b/src/llroundf.c
new file mode 100644
index 0000000..0e1ac8a
--- /dev/null
+++ b/src/llroundf.c
@@ -0,0 +1,132 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifdef WIN64
+#include <fpieee.h>
+#else
+#include <errno.h>
+#endif
+
+#include <math.h>
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#include "../inc/libm_special.h"
+
+#ifdef WINDOWS
+/*In windows llong long int is 64 bit and long int is 32 bit.
+  In Linux long long int and long int both are of size 64 bit*/
+long long int FN_PROTOTYPE(llroundf)(float f)
+{
+    UT32 u32d;
+    UT32 u32Temp,u32result;
+    int intexp, shift;
+    U32 sign;
+    long long int  result;
+
+    u32d.f32 = u32Temp.f32 = f;
+    if ((u32d.u32 & 0X7F800000) == 0x7F800000)
+    {
+        /*else the number is infinity*/
+		//Got to raise range or domain error
+        {
+            unsigned int is_x_snan;
+            UT32 xm; xm.f32 = f;
+            is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+            __amd_handle_errorf(DOMAIN, EDOM, "llroundf", f, is_x_snan, 0.0F , 0,(float)SIGNBIT_DP64, 0);
+			return SIGNBIT_DP64; /*GCC returns this when the number is out of range*/
+        }
+
+    }
+
+    u32Temp.u32 &= 0x7FFFFFFF;
+    intexp = (u32d.u32 & 0x7F800000) >> 23;
+    sign = u32d.u32 & 0x80000000;
+    intexp -= 0x7F;
+
+
+    /* 1.0 x 2^-1 is the smallest number which can be rounded to 1 */
+    if (intexp < -1)
+        return (0);
+
+
+    /* 1.0 x 2^31 (or 2^63) is already too large */
+    if (intexp >= 63)
+    {
+        result = 0x8000000000000000;
+            
+        {
+            unsigned int is_x_snan;
+            UT32 xm; xm.f32 = f;
+            is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+            __amd_handle_errorf(DOMAIN, EDOM, "lroundf", f, is_x_snan, 0.0F , 0,(float)result, 0);
+        }
+
+        return result;
+    }
+
+    u32result.f32 = u32Temp.f32;
+
+    /* >= 2^52 is already an exact integer */
+    if (intexp < 23)
+    {
+        /* add 0.5, extraction below will truncate */
+        u32result.f32 = u32Temp.f32 + 0.5F;
+    }
+    intexp = (u32result.u32 & 0x7f800000) >> 23;
+    intexp -= 0x7f;
+    u32result.u32 &= 0x7fffff;
+    u32result.u32 |= 0x00800000;
+
+    result = u32result.u32;
+
+    /*Since float is only 32 bit for higher accuracy we shift the result by 32 bits
+     * In the next step we shift an extra 32 bits in the reverse direction based
+     * on the value of intexp*/
+    result = result << 32;
+    shift = intexp - 55; /*55= 23 +32*/
+
+
+	if(shift < 0)
+		result = result >> (-shift);
+	if(shift > 0)
+        result = result << (shift);
+
+    if (sign)
+        result = -result;
+    return result;
+
+}
+
+#else //WINDOWS
+/*llroundf is equivalent to the linux implementation of 
+  lroundf. Both long int and long long int are of the same size*/
+long long int FN_PROTOTYPE(llroundf)(float f)
+{
+    long long int result;
+    result = FN_PROTOTYPE(lroundf)(f);
+    return result;
+
+}
+#endif
+
diff --git a/src/log1p.c b/src/log1p.c
new file mode 100644
index 0000000..b7cd097
--- /dev/null
+++ b/src/log1p.c
@@ -0,0 +1,475 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#define USE_NAN_WITH_FLAGS
+#define USE_VAL_WITH_FLAGS
+#define USE_INFINITY_WITH_FLAGS
+#define USE_HANDLE_ERROR
+#include "../inc/libm_inlines_amd.h"
+#undef USE_NAN_WITH_FLAGS
+#undef USE_VAL_WITH_FLAGS
+#undef USE_INFINITY_WITH_FLAGS
+#undef USE_HANDLE_ERROR
+
+#include "../inc/libm_errno_amd.h"
+
+#ifndef WINDOWS
+/* Deal with errno for out-of-range result */
+static inline double retval_errno_erange_overflow(double x)
+{
+  struct exception exc;
+  exc.arg1 = x;
+  exc.arg2 = x;
+  exc.type = SING;
+  exc.name = (char *)"log1p";
+  if (_LIB_VERSION == _SVID_)
+    exc.retval = -HUGE;
+  else
+    exc.retval = -infinity_with_flags(AMD_F_DIVBYZERO);
+  if (_LIB_VERSION == _POSIX_)
+    __set_errno(ERANGE);
+  else if (!matherr(&exc))
+    __set_errno(ERANGE);
+  return exc.retval;
+}
+
+/* Deal with errno for out-of-range argument */
+static inline double retval_errno_edom(double x)
+{
+  struct exception exc;
+  exc.arg1 = x;
+  exc.arg2 = x;
+  exc.type = DOMAIN;
+  exc.name = (char *)"log1p";
+  if (_LIB_VERSION == _SVID_)
+    exc.retval = -HUGE;
+  else
+    exc.retval = nan_with_flags(AMD_F_INVALID);
+  if (_LIB_VERSION == _POSIX_)
+    __set_errno(EDOM);
+  else if (!matherr(&exc))
+    {
+      if(_LIB_VERSION == _SVID_)
+        (void)fputs("log1p: DOMAIN error\n", stderr);
+    __set_errno(EDOM);
+    }
+  return exc.retval;
+}
+#endif
+
+#undef _FUNCNAME
+#define _FUNCNAME "log1p"
+
+double FN_PROTOTYPE(log1p)(double x)
+{
+
+  int xexp;
+  double r, r1, r2, correction, f, f1, f2, q, u, v, z1, z2, poly, m2;
+  int index;
+  unsigned long long ux, ax;
+
+  /*
+    Computes natural log(1+x). Algorithm based on:
+    Ping-Tak Peter Tang
+    "Table-driven implementation of the logarithm function in IEEE
+    floating-point arithmetic"
+    ACM Transactions on Mathematical Software (TOMS)
+    Volume 16, Issue 4 (December 1990)
+    Note that we use a lookup table of size 64 rather than 128,
+    and compensate by having extra terms in the minimax polynomial
+    for the kernel approximation.
+  */
+
+/* Arrays ln_lead_table and ln_tail_table contain
+   leading and trailing parts respectively of precomputed
+   values of natural log(1+i/64), for i = 0, 1, ..., 64.
+   ln_lead_table contains the first 24 bits of precision,
+   and ln_tail_table contains a further 53 bits precision. */
+
+  static const double ln_lead_table[65] = {
+    0.00000000000000000000e+00,   /* 0x0000000000000000 */
+    1.55041813850402832031e-02,   /* 0x3f8fc0a800000000 */
+    3.07716131210327148438e-02,   /* 0x3f9f829800000000 */
+    4.58095073699951171875e-02,   /* 0x3fa7745800000000 */
+    6.06245994567871093750e-02,   /* 0x3faf0a3000000000 */
+    7.52233862876892089844e-02,   /* 0x3fb341d700000000 */
+    8.96121263504028320312e-02,   /* 0x3fb6f0d200000000 */
+    1.03796780109405517578e-01,   /* 0x3fba926d00000000 */
+    1.17783010005950927734e-01,   /* 0x3fbe270700000000 */
+    1.31576299667358398438e-01,   /* 0x3fc0d77e00000000 */
+    1.45181953907012939453e-01,   /* 0x3fc2955280000000 */
+    1.58604979515075683594e-01,   /* 0x3fc44d2b00000000 */
+    1.71850204467773437500e-01,   /* 0x3fc5ff3000000000 */
+    1.84922337532043457031e-01,   /* 0x3fc7ab8900000000 */
+    1.97825729846954345703e-01,   /* 0x3fc9525a80000000 */
+    2.10564732551574707031e-01,   /* 0x3fcaf3c900000000 */
+    2.23143517971038818359e-01,   /* 0x3fcc8ff780000000 */
+    2.35566020011901855469e-01,   /* 0x3fce270700000000 */
+    2.47836112976074218750e-01,   /* 0x3fcfb91800000000 */
+    2.59957492351531982422e-01,   /* 0x3fd0a324c0000000 */
+    2.71933674812316894531e-01,   /* 0x3fd1675c80000000 */
+    2.83768117427825927734e-01,   /* 0x3fd22941c0000000 */
+    2.95464158058166503906e-01,   /* 0x3fd2e8e280000000 */
+    3.07025015354156494141e-01,   /* 0x3fd3a64c40000000 */
+    3.18453729152679443359e-01,   /* 0x3fd4618bc0000000 */
+    3.29753279685974121094e-01,   /* 0x3fd51aad80000000 */
+    3.40926527976989746094e-01,   /* 0x3fd5d1bd80000000 */
+    3.51976394653320312500e-01,   /* 0x3fd686c800000000 */
+    3.62905442714691162109e-01,   /* 0x3fd739d7c0000000 */
+    3.73716354370117187500e-01,   /* 0x3fd7eaf800000000 */
+    3.84411692619323730469e-01,   /* 0x3fd89a3380000000 */
+    3.94993782043457031250e-01,   /* 0x3fd9479400000000 */
+    4.05465066432952880859e-01,   /* 0x3fd9f323c0000000 */
+    4.15827870368957519531e-01,   /* 0x3fda9cec80000000 */
+    4.26084339618682861328e-01,   /* 0x3fdb44f740000000 */
+    4.36236739158630371094e-01,   /* 0x3fdbeb4d80000000 */
+    4.46287095546722412109e-01,   /* 0x3fdc8ff7c0000000 */
+    4.56237375736236572266e-01,   /* 0x3fdd32fe40000000 */
+    4.66089725494384765625e-01,   /* 0x3fddd46a00000000 */
+    4.75845873355865478516e-01,   /* 0x3fde744240000000 */
+    4.85507786273956298828e-01,   /* 0x3fdf128f40000000 */
+    4.95077252388000488281e-01,   /* 0x3fdfaf5880000000 */
+    5.04556000232696533203e-01,   /* 0x3fe02552a0000000 */
+    5.13945698738098144531e-01,   /* 0x3fe0723e40000000 */
+    5.23248136043548583984e-01,   /* 0x3fe0be72e0000000 */
+    5.32464742660522460938e-01,   /* 0x3fe109f380000000 */
+    5.41597247123718261719e-01,   /* 0x3fe154c3c0000000 */
+    5.50647079944610595703e-01,   /* 0x3fe19ee6a0000000 */
+    5.59615731239318847656e-01,   /* 0x3fe1e85f40000000 */
+    5.68504691123962402344e-01,   /* 0x3fe23130c0000000 */
+    5.77315330505371093750e-01,   /* 0x3fe2795e00000000 */
+    5.86049020290374755859e-01,   /* 0x3fe2c0e9e0000000 */
+    5.94707071781158447266e-01,   /* 0x3fe307d720000000 */
+    6.03290796279907226562e-01,   /* 0x3fe34e2880000000 */
+    6.11801505088806152344e-01,   /* 0x3fe393e0c0000000 */
+    6.20240390300750732422e-01,   /* 0x3fe3d90260000000 */
+    6.28608644008636474609e-01,   /* 0x3fe41d8fe0000000 */
+    6.36907458305358886719e-01,   /* 0x3fe4618bc0000000 */
+    6.45137906074523925781e-01,   /* 0x3fe4a4f840000000 */
+    6.53301239013671875000e-01,   /* 0x3fe4e7d800000000 */
+    6.61398470401763916016e-01,   /* 0x3fe52a2d20000000 */
+    6.69430613517761230469e-01,   /* 0x3fe56bf9c0000000 */
+    6.77398800849914550781e-01,   /* 0x3fe5ad4040000000 */
+    6.85303986072540283203e-01,   /* 0x3fe5ee02a0000000 */
+    6.93147122859954833984e-01};  /* 0x3fe62e42e0000000 */
+
+  static const double ln_tail_table[65] = {
+    0.00000000000000000000e+00,   /* 0x0000000000000000 */
+    5.15092497094772879206e-09,   /* 0x3e361f807c79f3db */
+    4.55457209735272790188e-08,   /* 0x3e6873c1980267c8 */
+    2.86612990859791781788e-08,   /* 0x3e5ec65b9f88c69e */
+    2.23596477332056055352e-08,   /* 0x3e58022c54cc2f99 */
+    3.49498983167142274770e-08,   /* 0x3e62c37a3a125330 */
+    3.23392843005887000414e-08,   /* 0x3e615cad69737c93 */
+    1.35722380472479366661e-08,   /* 0x3e4d256ab1b285e9 */
+    2.56504325268044191098e-08,   /* 0x3e5b8abcb97a7aa2 */
+    5.81213608741512136843e-08,   /* 0x3e6f34239659a5dc */
+    5.59374849578288093334e-08,   /* 0x3e6e07fd48d30177 */
+    5.06615629004996189970e-08,   /* 0x3e6b32df4799f4f6 */
+    5.24588857848400955725e-08,   /* 0x3e6c29e4f4f21cf8 */
+    9.61968535632653505972e-10,   /* 0x3e1086c848df1b59 */
+    1.34829655346594463137e-08,   /* 0x3e4cf456b4764130 */
+    3.65557749306383026498e-08,   /* 0x3e63a02ffcb63398 */
+    3.33431709374069198903e-08,   /* 0x3e61e6a6886b0976 */
+    5.13008650536088382197e-08,   /* 0x3e6b8abcb97a7aa2 */
+    5.09285070380306053751e-08,   /* 0x3e6b578f8aa35552 */
+    3.20853940845502057341e-08,   /* 0x3e6139c871afb9fc */
+    4.06713248643004200446e-08,   /* 0x3e65d5d30701ce64 */
+    5.57028186706125221168e-08,   /* 0x3e6de7bcb2d12142 */
+    5.48356693724804282546e-08,   /* 0x3e6d708e984e1664 */
+    1.99407553679345001938e-08,   /* 0x3e556945e9c72f36 */
+    1.96585517245087232086e-09,   /* 0x3e20e2f613e85bda */
+    6.68649386072067321503e-09,   /* 0x3e3cb7e0b42724f6 */
+    5.89936034642113390002e-08,   /* 0x3e6fac04e52846c7 */
+    2.85038578721554472484e-08,   /* 0x3e5e9b14aec442be */
+    5.09746772910284482606e-08,   /* 0x3e6b5de8034e7126 */
+    5.54234668933210171467e-08,   /* 0x3e6dc157e1b259d3 */
+    6.29100830926604004874e-09,   /* 0x3e3b05096ad69c62 */
+    2.61974119468563937716e-08,   /* 0x3e5c2116faba4cdd */
+    4.16752115011186398935e-08,   /* 0x3e665fcc25f95b47 */
+    2.47747534460820790327e-08,   /* 0x3e5a9a08498d4850 */
+    5.56922172017964209793e-08,   /* 0x3e6de647b1465f77 */
+    2.76162876992552906035e-08,   /* 0x3e5da71b7bf7861d */
+    7.08169709942321478061e-09,   /* 0x3e3e6a6886b09760 */
+    5.77453510221151779025e-08,   /* 0x3e6f0075eab0ef64 */
+    4.43021445893361960146e-09,   /* 0x3e33071282fb989b */
+    3.15140984357495864573e-08,   /* 0x3e60eb43c3f1bed2 */
+    2.95077445089736670973e-08,   /* 0x3e5faf06ecb35c84 */
+    1.44098510263167149349e-08,   /* 0x3e4ef1e63db35f68 */
+    1.05196987538551827693e-08,   /* 0x3e469743fb1a71a5 */
+    5.23641361722697546261e-08,   /* 0x3e6c1cdf404e5796 */
+    7.72099925253243069458e-09,   /* 0x3e4094aa0ada625e */
+    5.62089493829364197156e-08,   /* 0x3e6e2d4c96fde3ec */
+    3.53090261098577946927e-08,   /* 0x3e62f4d5e9a98f34 */
+    3.80080516835568242269e-08,   /* 0x3e6467c96ecc5cbe */
+    5.66961038386146408282e-08,   /* 0x3e6e7040d03dec5a */
+    4.42287063097349852717e-08,   /* 0x3e67bebf4282de36 */
+    3.45294525105681104660e-08,   /* 0x3e6289b11aeb783f */
+    2.47132034530447431509e-08,   /* 0x3e5a891d1772f538 */
+    3.59655343422487209774e-08,   /* 0x3e634f10be1fb591 */
+    5.51581770357780862071e-08,   /* 0x3e6d9ce1d316eb93 */
+    3.60171867511861372793e-08,   /* 0x3e63562a19a9c442 */
+    1.94511067964296180547e-08,   /* 0x3e54e2adf548084c */
+    1.54137376631349347838e-08,   /* 0x3e508ce55cc8c97a */
+    3.93171034490174464173e-09,   /* 0x3e30e2f613e85bda */
+    5.52990607758839766440e-08,   /* 0x3e6db03ebb0227bf */
+    3.29990737637586136511e-08,   /* 0x3e61b75bb09cb098 */
+    1.18436010922446096216e-08,   /* 0x3e496f16abb9df22 */
+    4.04248680368301346709e-08,   /* 0x3e65b3f399411c62 */
+    2.27418915900284316293e-08,   /* 0x3e586b3e59f65355 */
+    1.70263791333409206020e-08,   /* 0x3e52482ceae1ac12 */
+    5.76999904754328540596e-08};  /* 0x3e6efa39ef35793c */
+
+  /* log2_lead and log2_tail sum to an extra-precise version
+     of log(2) */
+  static const double
+    log2_lead = 6.93147122859954833984e-01,  /* 0x3fe62e42e0000000 */
+    log2_tail = 5.76999904754328540596e-08;  /* 0x3e6efa39ef35793c */
+
+  static const double
+  /* Approximating polynomial coefficients for x near 0.0 */
+    ca_1 = 8.33333333333317923934e-02,  /* 0x3fb55555555554e6 */
+    ca_2 = 1.25000000037717509602e-02,  /* 0x3f89999999bac6d4 */
+    ca_3 = 2.23213998791944806202e-03,  /* 0x3f62492307f1519f */
+    ca_4 = 4.34887777707614552256e-04,  /* 0x3f3c8034c85dfff0 */
+
+  /* Approximating polynomial coefficients for other x */
+    cb_1 = 8.33333333333333593622e-02,  /* 0x3fb5555555555557 */
+    cb_2 = 1.24999999978138668903e-02,  /* 0x3f89999999865ede */
+    cb_3 = 2.23219810758559851206e-03;  /* 0x3f6249423bd94741 */
+
+  /* The values exp(-1/16)-1 and exp(1/16)-1 */
+  static const double
+    log1p_thresh1 = -6.05869371865242201114e-02, /* 0xbfaf0540438fd5c4 */
+    log1p_thresh2 = 6.44944589178594318568e-02;  /* 0x3fb082b577d34ed8 */
+
+
+  GET_BITS_DP64(x, ux);
+  ax = ux & ~SIGNBIT_DP64;
+
+  if ((ux & EXPBITS_DP64) == EXPBITS_DP64)
+    {
+      /* x is either NaN or infinity */
+      if (ux & MANTBITS_DP64)
+        {
+          /* x is NaN */
+#ifdef WINDOWS
+          return handle_error(_FUNCNAME, ux|0x0008000000000000, _DOMAIN,
+                              0, EDOM, x, 0.0);
+#else
+          return x + x; /* Raise invalid if it is a signalling NaN */
+#endif
+        }
+      else
+        {
+          /* x is infinity */
+          if (ux & SIGNBIT_DP64)
+            /* x is negative infinity. Return a NaN. */
+#ifdef WINDOWS
+            return handle_error(_FUNCNAME, INDEFBITPATT_DP64, _DOMAIN,
+                                AMD_F_INVALID, EDOM, x, 0.0);
+#else
+            return retval_errno_edom(x);
+#endif
+          else
+            return x;
+        }
+    }
+  else if (ux >= 0xbff0000000000000)
+    {
+      /* x <= -1.0 */
+      if (ux > 0xbff0000000000000)
+        {
+          /* x is less than -1.0. Return a NaN. */
+#ifdef WINDOWS
+          return handle_error(_FUNCNAME, INDEFBITPATT_DP64, _DOMAIN,
+                              AMD_F_INVALID, EDOM, x, 0.0);
+#else
+          return retval_errno_edom(x);
+#endif
+        }
+      else
+        {
+          /* x is exactly -1.0. Return -infinity with div-by-zero flag. */
+#ifdef WINDOWS
+          return handle_error(_FUNCNAME, NINFBITPATT_DP64, _SING,
+                              AMD_F_DIVBYZERO, ERANGE, x, 0.0);
+#else
+          return retval_errno_erange_overflow(x);
+#endif
+        }
+    }
+  else if (ax < 0x3ca0000000000000)
+    {
+      if (ax == 0x0000000000000000)
+        {
+          /* x is +/-zero. Return the same zero. */
+          return x;
+        }
+      else
+        /* abs(x) is less than epsilon. Return x with inexact. */
+        return val_with_flags(x, AMD_F_INEXACT);
+    }
+
+
+  if (x < log1p_thresh1 || x > log1p_thresh2)
+    {
+      /* x is outside the range [exp(-1/16)-1, exp(1/16)-1] */
+      /*
+        First, we decompose the argument x to the form
+        1 + x  =  2**M  *  (F1  +  F2),
+        where  1 <= F1+F2 < 2, M has the value of an integer,
+        F1 = 1 + j/64, j ranges from 0 to 64, and |F2| <= 1/128.
+
+        Second, we approximate log( 1 + F2/F1 ) by an odd polynomial
+        in U, where U  =  2 F2 / (2 F1 + F2).
+        Note that log( 1 + F2/F1 ) = log( 1 + U/2 ) - log( 1 - U/2 ).
+        The core approximation calculates
+        Poly = [log( 1 + U/2 ) - log( 1 - U/2 )]/U   -   1.
+        Note that  log(1 + U/2) - log(1 - U/2) = 2 arctanh ( U/2 ),
+        thus, Poly =  2 arctanh( U/2 ) / U  -  1.
+
+        It is not hard to see that
+          log(x) = M*log(2) + log(F1) + log( 1 + F2/F1 ).
+        Hence, we return Z1 = log(F1), and  Z2 = log( 1 + F2/F1).
+        The values of log(F1) are calculated beforehand and stored
+        in the program.
+      */
+
+      f = 1.0 + x;
+      GET_BITS_DP64(f, ux);
+
+      /* Store the exponent of x in xexp and put
+         f into the range [1.0,2.0) */
+      xexp = (int)((ux & EXPBITS_DP64) >> EXPSHIFTBITS_DP64) - EXPBIAS_DP64;
+      PUT_BITS_DP64((ux & MANTBITS_DP64) | ONEEXPBITS_DP64, f);
+
+      /* Now  (1+x) = 2**(xexp)  * f,  1 <= f < 2. */
+
+      /* Set index to be the nearest integer to 64*f */
+      /* 64 <= index <= 128 */
+      /*
+        r = 64.0 * f;
+        index = (int)(r + 0.5);
+      */
+      /* This code instead of the above can save several cycles.
+         It only works because 64 <= r < 128, so
+         the nearest integer is always contained in exactly
+         7 bits, and the right shift is always the same. */
+      index = (int)((((ux & 0x000fc00000000000) | 0x0010000000000000) >> 46)
+                    + ((ux & 0x0000200000000000) >> 45));
+
+      f1 = index * 0.015625; /* 0.015625 = 1/64 */
+      index -= 64;
+
+      /* Now take great care to compute f2 such that f1 + f2 = f */
+      if (xexp <= -2 || xexp >= MANTLENGTH_DP64 + 8)
+        {
+          f2 = f - f1;
+        }
+      else
+        {
+          /* Create the number m2 = 2.0^(-xexp) */
+          ux = (unsigned long long)(0x3ff - xexp) << EXPSHIFTBITS_DP64;
+          PUT_BITS_DP64(ux,m2);
+          if (xexp <= MANTLENGTH_DP64 - 1)
+            {
+              f2 = (m2 - f1) + m2*x;
+            }
+          else
+            {
+              f2 = (m2*x - f1) + m2;
+            }
+        }
+
+      /* At this point, x = 2**xexp * ( f1  +  f2 ) where
+         f1 = j/64, j = 1, 2, ..., 64 and |f2| <= 1/128. */
+
+      z1 = ln_lead_table[index];
+      q = ln_tail_table[index];
+
+      /* Calculate u = 2 f2 / ( 2 f1 + f2 ) = f2 / ( f1 + 0.5*f2 ) */
+      u = f2 / (f1 + 0.5 * f2);
+
+      /* Here, |u| <= 2(exp(1/16)-1) / (exp(1/16)+1).
+         The core approximation calculates
+         poly = [log(1 + u/2) - log(1 - u/2)]/u  -  1  */
+      v = u * u;
+      poly = (v * (cb_1 + v * (cb_2 + v * cb_3)));
+      z2 = q + (u + u * poly);
+
+      /* Now z1,z2 is an extra-precise approximation of log(f). */
+
+      /* Add xexp * log(2) to z1,z2 to get the result log(1+x).
+         The computed r1 is not subject to rounding error because
+         xexp has at most 10 significant bits, log(2) has 24 significant
+         bits, and z1 has up to 24 bits; and the exponents of z1
+         and z2 differ by at most 6. */
+      r1 = (xexp * log2_lead + z1);
+      r2 = (xexp * log2_tail + z2);
+      /* Natural log(1+x) */
+      return r1 + r2;
+    }
+  else
+    {
+      /* Arguments close to 0.0 are handled separately to maintain
+         accuracy.
+
+         The approximation in this region exploits the identity
+             log( 1 + r ) = log( 1 + u/2 )  -  log( 1 - u/2 ), where
+             u  = 2r / (2+r).
+         Note that the right hand side has an odd Taylor series expansion
+         which converges much faster than the Taylor series expansion of
+         log( 1 + r ) in r. Thus, we approximate log( 1 + r ) by
+             u + A1 * u^3 + A2 * u^5 + ... + An * u^(2n+1).
+
+         One subtlety is that since u cannot be calculated from
+         r exactly, the rounding error in the first u should be
+         avoided if possible. To accomplish this, we observe that
+                       u  =  r  -  r*r/(2+r).
+         Since x (=r) is the input argument, and thus presumed exact,
+         the formula above approximates u accurately because
+                       u  =  r  -  correction,
+         and the magnitude of "correction" (of the order of r*r)
+         is small.
+         With these observations, we will approximate log( 1 + r ) by
+            r + (  (A1*u^3 + ... + An*u^(2n+1)) - correction ).
+
+         We approximate log(1+r) by an odd polynomial in u, where
+                  u = 2r/(2+r) = r - r*r/(2+r).
+      */
+      r = x;
+      u = r / (2.0 + r);
+      correction = r * u;
+      u          = u + u;
+      v          = u * u;
+      r1 = r;
+      r2 = (u * v * (ca_1 + v * (ca_2 + v * (ca_3 + v * ca_4))) - correction);
+      return r1 + r2;
+    }
+}
+
+weak_alias (__log1p, log1p)
diff --git a/src/log1pf.c b/src/log1pf.c
new file mode 100644
index 0000000..375a846
--- /dev/null
+++ b/src/log1pf.c
@@ -0,0 +1,416 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#define USE_NANF_WITH_FLAGS
+#define USE_VALF_WITH_FLAGS
+#define USE_INFINITYF_WITH_FLAGS
+#define USE_HANDLE_ERRORF
+#include "../inc/libm_inlines_amd.h"
+#undef USE_NANF_WITH_FLAGS
+#undef USE_VALF_WITH_FLAGS
+#undef USE_INFINITYF_WITH_FLAGS
+#undef USE_HANDLE_ERRORF
+
+#include "../inc/libm_errno_amd.h"
+
+#ifndef WINDOWS
+/* Deal with errno for out-of-range result */
+static inline float retval_errno_erange_overflow(float x)
+{
+  struct exception exc;
+  exc.arg1 = (double)x;
+  exc.arg2 = (double)x;
+  exc.type = SING;
+  exc.name = (char *)"log1pf";
+  if (_LIB_VERSION == _SVID_)
+    exc.retval = -HUGE;
+  else
+    exc.retval = -infinityf_with_flags(AMD_F_DIVBYZERO);
+  if (_LIB_VERSION == _POSIX_)
+    __set_errno(ERANGE);
+  else if (!matherr(&exc))
+    __set_errno(ERANGE);
+  return exc.retval;
+}
+
+/* Deal with errno for out-of-range argument */
+static inline float retval_errno_edom(float x)
+{
+  struct exception exc;
+  exc.arg1 = (double)x;
+  exc.arg2 = (double)x;
+  exc.type = DOMAIN;
+  exc.name = (char *)"log1pf";
+  if (_LIB_VERSION == _SVID_)
+    exc.retval = -HUGE;
+  else
+    exc.retval = nanf_with_flags(AMD_F_INVALID);
+  if (_LIB_VERSION == _POSIX_)
+    __set_errno(EDOM);
+  else if (!matherr(&exc))
+    {
+      if(_LIB_VERSION == _SVID_)
+        (void)fputs("log1pf: DOMAIN error\n", stderr);
+    __set_errno(EDOM);
+    }
+  return exc.retval;
+}
+#endif
+
+#undef _FUNCNAME
+#define _FUNCNAME "log1pf"
+
+float FN_PROTOTYPE(log1pf)(float x)
+{
+
+  int xexp;
+  double dx, r, f, f1, f2, q, u, v, z1, z2, poly, m2;
+  int index;
+  unsigned int ux, ax;
+  unsigned long long lux;
+
+  /*
+    Computes natural log(1+x) for float arguments. Algorithm is
+    basically a promotion of the arguments to double followed
+    by an inlined version of the double algorithm, simplified
+    for efficiency (see log1p_amd.c). Simplifications include:
+    * Special algorithm for arguments near 0.0 not required
+    * Scaling of denormalised arguments not required
+    * Shorter core series approximations used
+    Note that we use a lookup table of size 64 rather than 128,
+    and compensate by having extra terms in the minimax polynomial
+    for the kernel approximation.
+  */
+
+/* Arrays ln_lead_table and ln_tail_table contain
+   leading and trailing parts respectively of precomputed
+   values of natural log(1+i/64), for i = 0, 1, ..., 64.
+   ln_lead_table contains the first 24 bits of precision,
+   and ln_tail_table contains a further 53 bits precision. */
+
+  static const double ln_lead_table[65] = {
+    0.00000000000000000000e+00,   /* 0x0000000000000000 */
+    1.55041813850402832031e-02,   /* 0x3f8fc0a800000000 */
+    3.07716131210327148438e-02,   /* 0x3f9f829800000000 */
+    4.58095073699951171875e-02,   /* 0x3fa7745800000000 */
+    6.06245994567871093750e-02,   /* 0x3faf0a3000000000 */
+    7.52233862876892089844e-02,   /* 0x3fb341d700000000 */
+    8.96121263504028320312e-02,   /* 0x3fb6f0d200000000 */
+    1.03796780109405517578e-01,   /* 0x3fba926d00000000 */
+    1.17783010005950927734e-01,   /* 0x3fbe270700000000 */
+    1.31576299667358398438e-01,   /* 0x3fc0d77e00000000 */
+    1.45181953907012939453e-01,   /* 0x3fc2955280000000 */
+    1.58604979515075683594e-01,   /* 0x3fc44d2b00000000 */
+    1.71850204467773437500e-01,   /* 0x3fc5ff3000000000 */
+    1.84922337532043457031e-01,   /* 0x3fc7ab8900000000 */
+    1.97825729846954345703e-01,   /* 0x3fc9525a80000000 */
+    2.10564732551574707031e-01,   /* 0x3fcaf3c900000000 */
+    2.23143517971038818359e-01,   /* 0x3fcc8ff780000000 */
+    2.35566020011901855469e-01,   /* 0x3fce270700000000 */
+    2.47836112976074218750e-01,   /* 0x3fcfb91800000000 */
+    2.59957492351531982422e-01,   /* 0x3fd0a324c0000000 */
+    2.71933674812316894531e-01,   /* 0x3fd1675c80000000 */
+    2.83768117427825927734e-01,   /* 0x3fd22941c0000000 */
+    2.95464158058166503906e-01,   /* 0x3fd2e8e280000000 */
+    3.07025015354156494141e-01,   /* 0x3fd3a64c40000000 */
+    3.18453729152679443359e-01,   /* 0x3fd4618bc0000000 */
+    3.29753279685974121094e-01,   /* 0x3fd51aad80000000 */
+    3.40926527976989746094e-01,   /* 0x3fd5d1bd80000000 */
+    3.51976394653320312500e-01,   /* 0x3fd686c800000000 */
+    3.62905442714691162109e-01,   /* 0x3fd739d7c0000000 */
+    3.73716354370117187500e-01,   /* 0x3fd7eaf800000000 */
+    3.84411692619323730469e-01,   /* 0x3fd89a3380000000 */
+    3.94993782043457031250e-01,   /* 0x3fd9479400000000 */
+    4.05465066432952880859e-01,   /* 0x3fd9f323c0000000 */
+    4.15827870368957519531e-01,   /* 0x3fda9cec80000000 */
+    4.26084339618682861328e-01,   /* 0x3fdb44f740000000 */
+    4.36236739158630371094e-01,   /* 0x3fdbeb4d80000000 */
+    4.46287095546722412109e-01,   /* 0x3fdc8ff7c0000000 */
+    4.56237375736236572266e-01,   /* 0x3fdd32fe40000000 */
+    4.66089725494384765625e-01,   /* 0x3fddd46a00000000 */
+    4.75845873355865478516e-01,   /* 0x3fde744240000000 */
+    4.85507786273956298828e-01,   /* 0x3fdf128f40000000 */
+    4.95077252388000488281e-01,   /* 0x3fdfaf5880000000 */
+    5.04556000232696533203e-01,   /* 0x3fe02552a0000000 */
+    5.13945698738098144531e-01,   /* 0x3fe0723e40000000 */
+    5.23248136043548583984e-01,   /* 0x3fe0be72e0000000 */
+    5.32464742660522460938e-01,   /* 0x3fe109f380000000 */
+    5.41597247123718261719e-01,   /* 0x3fe154c3c0000000 */
+    5.50647079944610595703e-01,   /* 0x3fe19ee6a0000000 */
+    5.59615731239318847656e-01,   /* 0x3fe1e85f40000000 */
+    5.68504691123962402344e-01,   /* 0x3fe23130c0000000 */
+    5.77315330505371093750e-01,   /* 0x3fe2795e00000000 */
+    5.86049020290374755859e-01,   /* 0x3fe2c0e9e0000000 */
+    5.94707071781158447266e-01,   /* 0x3fe307d720000000 */
+    6.03290796279907226562e-01,   /* 0x3fe34e2880000000 */
+    6.11801505088806152344e-01,   /* 0x3fe393e0c0000000 */
+    6.20240390300750732422e-01,   /* 0x3fe3d90260000000 */
+    6.28608644008636474609e-01,   /* 0x3fe41d8fe0000000 */
+    6.36907458305358886719e-01,   /* 0x3fe4618bc0000000 */
+    6.45137906074523925781e-01,   /* 0x3fe4a4f840000000 */
+    6.53301239013671875000e-01,   /* 0x3fe4e7d800000000 */
+    6.61398470401763916016e-01,   /* 0x3fe52a2d20000000 */
+    6.69430613517761230469e-01,   /* 0x3fe56bf9c0000000 */
+    6.77398800849914550781e-01,   /* 0x3fe5ad4040000000 */
+    6.85303986072540283203e-01,   /* 0x3fe5ee02a0000000 */
+    6.93147122859954833984e-01};  /* 0x3fe62e42e0000000 */
+
+  static const double ln_tail_table[65] = {
+    0.00000000000000000000e+00,   /* 0x0000000000000000 */
+    5.15092497094772879206e-09,   /* 0x3e361f807c79f3db */
+    4.55457209735272790188e-08,   /* 0x3e6873c1980267c8 */
+    2.86612990859791781788e-08,   /* 0x3e5ec65b9f88c69e */
+    2.23596477332056055352e-08,   /* 0x3e58022c54cc2f99 */
+    3.49498983167142274770e-08,   /* 0x3e62c37a3a125330 */
+    3.23392843005887000414e-08,   /* 0x3e615cad69737c93 */
+    1.35722380472479366661e-08,   /* 0x3e4d256ab1b285e9 */
+    2.56504325268044191098e-08,   /* 0x3e5b8abcb97a7aa2 */
+    5.81213608741512136843e-08,   /* 0x3e6f34239659a5dc */
+    5.59374849578288093334e-08,   /* 0x3e6e07fd48d30177 */
+    5.06615629004996189970e-08,   /* 0x3e6b32df4799f4f6 */
+    5.24588857848400955725e-08,   /* 0x3e6c29e4f4f21cf8 */
+    9.61968535632653505972e-10,   /* 0x3e1086c848df1b59 */
+    1.34829655346594463137e-08,   /* 0x3e4cf456b4764130 */
+    3.65557749306383026498e-08,   /* 0x3e63a02ffcb63398 */
+    3.33431709374069198903e-08,   /* 0x3e61e6a6886b0976 */
+    5.13008650536088382197e-08,   /* 0x3e6b8abcb97a7aa2 */
+    5.09285070380306053751e-08,   /* 0x3e6b578f8aa35552 */
+    3.20853940845502057341e-08,   /* 0x3e6139c871afb9fc */
+    4.06713248643004200446e-08,   /* 0x3e65d5d30701ce64 */
+    5.57028186706125221168e-08,   /* 0x3e6de7bcb2d12142 */
+    5.48356693724804282546e-08,   /* 0x3e6d708e984e1664 */
+    1.99407553679345001938e-08,   /* 0x3e556945e9c72f36 */
+    1.96585517245087232086e-09,   /* 0x3e20e2f613e85bda */
+    6.68649386072067321503e-09,   /* 0x3e3cb7e0b42724f6 */
+    5.89936034642113390002e-08,   /* 0x3e6fac04e52846c7 */
+    2.85038578721554472484e-08,   /* 0x3e5e9b14aec442be */
+    5.09746772910284482606e-08,   /* 0x3e6b5de8034e7126 */
+    5.54234668933210171467e-08,   /* 0x3e6dc157e1b259d3 */
+    6.29100830926604004874e-09,   /* 0x3e3b05096ad69c62 */
+    2.61974119468563937716e-08,   /* 0x3e5c2116faba4cdd */
+    4.16752115011186398935e-08,   /* 0x3e665fcc25f95b47 */
+    2.47747534460820790327e-08,   /* 0x3e5a9a08498d4850 */
+    5.56922172017964209793e-08,   /* 0x3e6de647b1465f77 */
+    2.76162876992552906035e-08,   /* 0x3e5da71b7bf7861d */
+    7.08169709942321478061e-09,   /* 0x3e3e6a6886b09760 */
+    5.77453510221151779025e-08,   /* 0x3e6f0075eab0ef64 */
+    4.43021445893361960146e-09,   /* 0x3e33071282fb989b */
+    3.15140984357495864573e-08,   /* 0x3e60eb43c3f1bed2 */
+    2.95077445089736670973e-08,   /* 0x3e5faf06ecb35c84 */
+    1.44098510263167149349e-08,   /* 0x3e4ef1e63db35f68 */
+    1.05196987538551827693e-08,   /* 0x3e469743fb1a71a5 */
+    5.23641361722697546261e-08,   /* 0x3e6c1cdf404e5796 */
+    7.72099925253243069458e-09,   /* 0x3e4094aa0ada625e */
+    5.62089493829364197156e-08,   /* 0x3e6e2d4c96fde3ec */
+    3.53090261098577946927e-08,   /* 0x3e62f4d5e9a98f34 */
+    3.80080516835568242269e-08,   /* 0x3e6467c96ecc5cbe */
+    5.66961038386146408282e-08,   /* 0x3e6e7040d03dec5a */
+    4.42287063097349852717e-08,   /* 0x3e67bebf4282de36 */
+    3.45294525105681104660e-08,   /* 0x3e6289b11aeb783f */
+    2.47132034530447431509e-08,   /* 0x3e5a891d1772f538 */
+    3.59655343422487209774e-08,   /* 0x3e634f10be1fb591 */
+    5.51581770357780862071e-08,   /* 0x3e6d9ce1d316eb93 */
+    3.60171867511861372793e-08,   /* 0x3e63562a19a9c442 */
+    1.94511067964296180547e-08,   /* 0x3e54e2adf548084c */
+    1.54137376631349347838e-08,   /* 0x3e508ce55cc8c97a */
+    3.93171034490174464173e-09,   /* 0x3e30e2f613e85bda */
+    5.52990607758839766440e-08,   /* 0x3e6db03ebb0227bf */
+    3.29990737637586136511e-08,   /* 0x3e61b75bb09cb098 */
+    1.18436010922446096216e-08,   /* 0x3e496f16abb9df22 */
+    4.04248680368301346709e-08,   /* 0x3e65b3f399411c62 */
+    2.27418915900284316293e-08,   /* 0x3e586b3e59f65355 */
+    1.70263791333409206020e-08,   /* 0x3e52482ceae1ac12 */
+    5.76999904754328540596e-08};  /* 0x3e6efa39ef35793c */
+
+  static const double
+    log2 = 6.931471805599453e-01,       /* 0x3fe62e42fefa39ef */
+
+  /* Approximating polynomial coefficients */
+    cb_1 = 8.33333333333333593622e-02,  /* 0x3fb5555555555557 */
+    cb_2 = 1.24999999978138668903e-02;  /* 0x3f89999999865ede */
+
+  GET_BITS_SP32(x, ux);
+  ax = ux & ~SIGNBIT_SP32;
+
+  if ((ux & EXPBITS_SP32) == EXPBITS_SP32)
+    {
+      /* x is either NaN or infinity */
+      if (ux & MANTBITS_SP32)
+        {
+          /* x is NaN */
+#ifdef WINDOWS
+          return handle_errorf(_FUNCNAME, ux|0x00400000, _DOMAIN,
+                               0, EDOM, x, 0.0F);
+#else
+          return x + x; /* Raise invalid if it is a signalling NaN */
+#endif
+        }
+      else
+        {
+          /* x is infinity */
+          if (ux & SIGNBIT_SP32)
+            {
+              /* x is negative infinity. Return a NaN. */
+#ifdef WINDOWS
+              return handle_errorf(_FUNCNAME, INDEFBITPATT_SP32, _DOMAIN,
+                                   AMD_F_INVALID, EDOM, x, 0.0F);
+#else
+              return retval_errno_edom(x);
+#endif
+            }
+          else
+            return x;
+        }
+    }
+  else if (ux >= 0xbf800000)
+    {
+      /* x <= -1.0 */
+      if (ux > 0xbf800000)
+        {
+          /* x is less than -1.0. Return a NaN. */
+#ifdef WINDOWS
+          return handle_errorf(_FUNCNAME, INDEFBITPATT_SP32, _DOMAIN,
+                               AMD_F_INVALID, EDOM, x, 0.0F);
+#else
+          return retval_errno_edom(x);
+#endif
+        }
+      else
+        {
+          /* x is exactly -1.0. Return -infinity with div-by-zero flag. */
+#ifdef WINDOWS
+          return handle_errorf(_FUNCNAME, NINFBITPATT_SP32, _SING,
+                               AMD_F_DIVBYZERO, ERANGE, x, 0.0F);
+#else
+          return retval_errno_erange_overflow(x);
+#endif
+        }
+    }
+  else if (ax < 0x33800000)
+    {
+      if (ax == 0x00000000)
+        {
+          /* x is +/-zero. Return the same zero. */
+          return x;
+        }
+      else
+        /* abs(x) is less than float epsilon. Return x with inexact. */
+        return valf_with_flags(x, AMD_F_INEXACT);
+    }
+
+  dx = x;
+  /*
+    First, we decompose the argument dx to the form
+    1 + dx  =  2**M  *  (F1  +  F2),
+    where  1 <= F1+F2 < 2, M has the value of an integer,
+    F1 = 1 + j/64, j ranges from 0 to 64, and |F2| <= 1/128.
+
+    Second, we approximate log( 1 + F2/F1 ) by an odd polynomial
+    in U, where U  =  2 F2 / (2 F2 + F1).
+    Note that log( 1 + F2/F1 ) = log( 1 + U/2 ) - log( 1 - U/2 ).
+    The core approximation calculates
+    Poly = [log( 1 + U/2 ) - log( 1 - U/2 )]/U   -   1.
+    Note that  log(1 + U/2) - log(1 - U/2) = 2 arctanh ( U/2 ),
+    thus, Poly =  2 arctanh( U/2 ) / U  -  1.
+
+    It is not hard to see that
+    log(dx) = M*log(2) + log(F1) + log( 1 + F2/F1 ).
+    Hence, we return Z1 = log(F1), and  Z2 = log( 1 + F2/F1).
+    The values of log(F1) are calculated beforehand and stored
+    in the program.
+  */
+
+  f = 1.0 + dx;
+  GET_BITS_DP64(f, lux);
+
+  /* Store the exponent of f = 1 + dx in xexp and put
+     f into the range [1.0,2.0) */
+  xexp = (int)((lux & EXPBITS_DP64) >> EXPSHIFTBITS_DP64) - EXPBIAS_DP64;
+  PUT_BITS_DP64((lux & MANTBITS_DP64) | ONEEXPBITS_DP64, f);
+
+  /* Now  (1+dx) = 2**(xexp)  * f,  1 <= f < 2. */
+
+  /* Set index to be the nearest integer to 64*f */
+  /* 64 <= index <= 128 */
+  /*
+    r = 64.0 * f;
+    index = (int)(r + 0.5);
+  */
+  /* This code instead of the above can save several cycles.
+     It only works because 64 <= r < 128, so
+     the nearest integer is always contained in exactly
+     7 bits, and the right shift is always the same. */
+  index = (int)((((lux & 0x000fc00000000000) | 0x0010000000000000) >> 46)
+                + ((lux & 0x0000200000000000) >> 45));
+
+  f1 = index * 0.015625; /* 0.015625 = 1/64 */
+  index -= 64;
+
+  /* Now take great care to compute f2 such that f1 + f2 = f */
+  if (xexp <= -2 || xexp >= MANTLENGTH_DP64 + 8)
+      {
+        f2 = f - f1;
+      }
+    else
+      {
+        /* Create the number m2 = 2.0^(-xexp) */
+        lux = (unsigned long long)(0x3ff - xexp) << EXPSHIFTBITS_DP64;
+        PUT_BITS_DP64(lux,m2);
+        if (xexp <= MANTLENGTH_DP64 - 1)
+          {
+            f2 = (m2 - f1) + m2*dx;
+          }
+        else
+          {
+            f2 = (m2*dx - f1) + m2;
+          }
+      }
+
+  /* At this point, dx = 2**xexp * ( f1  +  f2 ) where
+     f1 = j/64, j = 1, 2, ..., 64 and |f2| <= 1/128. */
+
+  z1 = ln_lead_table[index];
+  q = ln_tail_table[index];
+
+  /* Calculate u = 2 f2 / ( 2 f1 + f2 ) = f2 / ( f1 + 0.5*f2 ) */
+  u = f2 / (f1 + 0.5 * f2);
+
+  /* Here, |u| <= 2(exp(1/16)-1) / (exp(1/16)+1).
+     The core approximation calculates
+     poly = [log(1 + u/2) - log(1 - u/2)]/u  -  1  */
+  v = u * u;
+  poly = (v * (cb_1 + v * cb_2));
+  z2 = q + (u + u * poly);
+
+  /* Now z1,z2 is an extra-precise approximation of log(f). */
+
+  /* Add xexp * log(2) to z1,z2 to get the result log(1+x). */
+  r = xexp * log2 + z1 + z2;
+  /* Natural log(1+x) */
+  return (float)r;
+}
+
+weak_alias (__log1pf, log1pf)
diff --git a/src/log_special.c b/src/log_special.c
new file mode 100644
index 0000000..53a92b8
--- /dev/null
+++ b/src/log_special.c
@@ -0,0 +1,141 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+#ifdef __x86_64__
+
+#include <emmintrin.h>
+#include <math.h>
+#include <errno.h>
+
+#include "../inc/libm_util_amd.h"
+#include "../inc/libm_special.h"
+
+// y = log10f(x)
+// y = log10(x)
+// y = logf(x)
+// y = log(x)
+
+// these codes and the ones in the related .S or .asm files have to match
+#define LOG_X_ZERO      1
+#define LOG_X_NEG       2
+#define LOG_X_NAN       3
+
+static float _logf_special_common(float x, float y, U32 code, const char *name)
+{
+    switch(code)
+    {
+    case LOG_X_ZERO:
+        {
+            _mm_setcsr(_mm_getcsr() | MXCSR_ES_DIVBYZERO);
+            __amd_handle_errorf(SING, ERANGE, name, x, 0, 0.0f, 0, y, 0);
+        }
+        break;
+
+    case LOG_X_NEG:
+        {
+            _mm_setcsr(_mm_getcsr() | MXCSR_ES_INVALID);
+            __amd_handle_errorf(DOMAIN, EDOM, name, x, 0, 0.0f, 0, y, 0);
+        }
+        break;
+
+    case LOG_X_NAN:
+        {
+#ifdef WIN64
+            // y is assumed to be qnan, only check x for snan
+            unsigned int is_x_snan;
+            UT32 xm; xm.f32 = x;
+            is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+            __amd_handle_errorf(DOMAIN, EDOM, name, x, is_x_snan, 0.0f, 0, y, 0);
+#else
+            _mm_setcsr(_mm_getcsr() | MXCSR_ES_INVALID);
+#endif
+        }
+        break;
+    }
+
+    return y;
+}
+
+float _logf_special(float x, float y, U32 code)
+{
+    return _logf_special_common(x, y, code, "logf");
+}
+
+float _log10f_special(float x, float y, U32 code)
+{
+    return _logf_special_common(x, y, code, "log10f");
+}
+
+float _log2f_special(float x, float y, U32 code)
+{
+    return _logf_special_common(x, y, code, "log2f");
+}
+
+static double _log_special_common(double x, double y, U32 code,
+                                  const char *name)
+{
+    switch(code)
+    {
+    case LOG_X_ZERO:
+        {
+            _mm_setcsr(_mm_getcsr() | MXCSR_ES_DIVBYZERO);
+            __amd_handle_error(SING, ERANGE, name, x, 0.0, y);
+        }
+        break;
+
+    case LOG_X_NEG:
+        {
+            _mm_setcsr(_mm_getcsr() | MXCSR_ES_INVALID);
+            __amd_handle_error(DOMAIN, EDOM, name, x, 0.0, y);
+        }
+        break;
+
+    case LOG_X_NAN:
+        {
+#ifdef WIN64
+            __amd_handle_error(DOMAIN, EDOM, name, x, 0.0, y);
+#else
+            _mm_setcsr(_mm_getcsr() | MXCSR_ES_INVALID);
+#endif
+        }
+        break;
+    }
+
+    return y;
+}
+
+double _log_special(double x, double y, U32 code)
+{
+    return _log_special_common(x, y, code, "log");
+}
+
+double _log10_special(double x, double y, U32 code)
+{
+    return _log_special_common(x, y, code, "log10");
+}
+
+double _log2_special(double x, double y, U32 code)
+{
+    return _log_special_common(x, y, code, "log2");
+}
+
+#endif /* __x86_64__ */
diff --git a/src/logb.c b/src/logb.c
new file mode 100644
index 0000000..7c75ef1
--- /dev/null
+++ b/src/logb.c
@@ -0,0 +1,102 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#define USE_INFINITY_WITH_FLAGS
+#define USE_HANDLE_ERROR
+#include "../inc/libm_inlines_amd.h"
+#undef USE_INFINITY_WITH_FLAGS
+#undef USE_HANDLE_ERROR
+
+#ifdef WINDOWS
+#include "../inc/libm_errno_amd.h"
+#endif
+
+#ifdef WINDOWS
+double FN_PROTOTYPE(logb)(double x)
+#else
+double FN_PROTOTYPE(logb)(double x)
+#endif
+{
+
+  unsigned long long ux;
+  long long u;
+  GET_BITS_DP64(x, ux);
+  u = ((ux & EXPBITS_DP64) >> EXPSHIFTBITS_DP64) - EXPBIAS_DP64;
+  if ((ux & ~SIGNBIT_DP64) == 0)
+    /* x is +/-zero. Return -infinity with div-by-zero flag. */
+#ifdef WINDOWS
+    return handle_error("logb", NINFBITPATT_DP64, _SING,
+                        AMD_F_DIVBYZERO, ERANGE, x, 0.0);
+#else
+    return -infinity_with_flags(AMD_F_DIVBYZERO);
+#endif
+  else if (EMIN_DP64 <= u && u <= EMAX_DP64)
+    /* x is a normal number */
+    return (double)u;
+  else if (u > EMAX_DP64)
+    {
+      /* x is infinity or NaN */
+      if ((ux & MANTBITS_DP64) == 0)
+#ifdef WINDOWS
+        /* x is +/-infinity. For VC++, return infinity of same sign. */
+        return x;
+#else
+        /* x is +/-infinity. Return +infinity with no flags. */
+        return infinity_with_flags(0);
+#endif
+      else
+        /* x is NaN, result is NaN */
+#ifdef WINDOWS
+        return handle_error("logb", ux|0x0008000000000000, _DOMAIN,
+                            AMD_F_INVALID, EDOM, x, 0.0);
+#else
+        return x + x; /* Raise invalid if it is a signalling NaN */
+#endif
+    }
+  else
+    {
+      /* x is denormalized. */
+#ifdef FOLLOW_IEEE754_LOGB
+      /* Return the value of the minimum exponent to ensure that
+         the relationship between logb and scalb, defined in
+         IEEE 754, holds. */
+      return EMIN_DP64;
+#else
+      /* Follow the rule set by IEEE 854 for logb */
+      ux &= MANTBITS_DP64;
+      u = EMIN_DP64;
+      while (ux < IMPBIT_DP64)
+        {
+          ux <<= 1;
+          u--;
+        }
+      return (double)u;
+#endif
+    }
+
+}
+
+weak_alias (__logb, logb)
diff --git a/src/logbf.c b/src/logbf.c
new file mode 100644
index 0000000..d64e531
--- /dev/null
+++ b/src/logbf.c
@@ -0,0 +1,100 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#define USE_INFINITYF_WITH_FLAGS
+#define USE_HANDLE_ERRORF
+#include "../inc/libm_inlines_amd.h"
+#undef USE_INFINITYF_WITH_FLAGS
+#undef USE_HANDLE_ERRORF
+
+#ifdef WINDOWS
+#include "../inc/libm_errno_amd.h"
+#endif
+
+#ifdef WINDOWS
+float FN_PROTOTYPE(logbf)(float x)
+#else
+float FN_PROTOTYPE(logbf)(float x)
+#endif
+{
+  unsigned int ux;
+  int u;
+  GET_BITS_SP32(x, ux);
+  u = ((ux & EXPBITS_SP32) >> EXPSHIFTBITS_SP32) - EXPBIAS_SP32;
+  if ((ux & ~SIGNBIT_SP32) == 0)
+    /* x is +/-zero. Return -infinity with div-by-zero flag. */
+#ifdef WINDOWS
+    return handle_errorf("logbf", NINFBITPATT_SP32, _SING,
+                         AMD_F_DIVBYZERO, ERANGE, x, 0.0F);
+#else
+    return -infinityf_with_flags(AMD_F_DIVBYZERO);
+#endif
+  else if (EMIN_SP32 <= u && u <= EMAX_SP32)
+    /* x is a normal number */
+    return (float)u;
+  else if (u > EMAX_SP32)
+    {
+      /* x is infinity or NaN */
+      if ((ux & MANTBITS_SP32) == 0)
+#ifdef WINDOWS
+        /* x is +/-infinity. For VC++, return infinity of same sign. */
+        return x;
+#else
+        /* x is +/-infinity. Return +infinity with no flags. */
+        return infinityf_with_flags(0);
+#endif
+      else
+        /* x is NaN, result is NaN */
+#ifdef WINDOWS
+        return handle_errorf("logbf", ux|0x00400000, _DOMAIN,
+                             AMD_F_INVALID, EDOM, x, 0.0F);
+#else
+        return x + x; /* Raise invalid if it is a signalling NaN */
+#endif
+    }
+  else
+    {
+      /* x is denormalized. */
+#ifdef FOLLOW_IEEE754_LOGB
+      /* Return the value of the minimum exponent to ensure that
+         the relationship between logb and scalb, defined in
+         IEEE 754, holds. */
+      return EMIN_SP32;
+#else
+      /* Follow the rule set by IEEE 854 for logb */
+      ux &= MANTBITS_SP32;
+      u = EMIN_SP32;
+      while (ux < IMPBIT_SP32)
+        {
+          ux <<= 1;
+          u--;
+        }
+      return (float)u;
+#endif
+    }
+}
+
+weak_alias (__logbf, logbf)
diff --git a/src/lrint.c b/src/lrint.c
new file mode 100644
index 0000000..e3c0e41
--- /dev/null
+++ b/src/lrint.c
@@ -0,0 +1,62 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifdef WIN64
+#include <fpieee.h>
+#else
+#include <errno.h>
+#endif
+
+#include <math.h>
+
+#include "libm_amd.h"
+#include "libm_util_amd.h"
+#include "libm_special.h"
+
+
+
+long int FN_PROTOTYPE(lrint)(double x)
+{
+
+    UT64 checkbits,val_2p52;
+    checkbits.f64=x;
+
+    /* Clear the sign bit and check if the value can be rounded */
+
+    if( (checkbits.u64 & 0x7FFFFFFFFFFFFFFF) > 0x4330000000000000)
+    {
+        /* number cant be rounded raise an exception */
+        /* Number exceeds the representable range could be nan or inf also*/
+		__amd_handle_error(DOMAIN, EDOM, "lrint", x,0.0 ,(double)x);
+
+
+		return (long int) x;
+    }
+
+    val_2p52.u32[1] = (checkbits.u32[1] & 0x80000000) | 0x43300000;
+    val_2p52.u32[0] = 0;
+
+	/* Add and sub 2^52 to round the number according to the current rounding direction */
+
+    return (long int) ((x + val_2p52.f64) - val_2p52.f64);
+}
diff --git a/src/lrintf.c b/src/lrintf.c
new file mode 100644
index 0000000..abcd37b
--- /dev/null
+++ b/src/lrintf.c
@@ -0,0 +1,67 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifdef WIN64
+#include <fpieee.h>
+#else
+#include <errno.h>
+#endif
+
+#include <math.h>
+
+#include "libm_amd.h"
+#include "libm_util_amd.h"
+#include "libm_special.h"
+
+
+
+long int FN_PROTOTYPE(lrintf)(float x)
+{
+
+    UT32 checkbits,val_2p23;
+    checkbits.f32=x;
+
+    /* Clear the sign bit and check if the value can be rounded */
+
+    if( (checkbits.u32 & 0x7FFFFFFF) > 0x4B000000)
+    {
+        /* number cant be rounded raise an exception */
+        /* Number exceeds the representable range could be nan or inf also*/
+
+        {
+            unsigned int is_x_snan;
+            UT32 xm; xm.f32 = x;
+            is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+            __amd_handle_errorf(DOMAIN, EDOM, "lrintf", x, is_x_snan, 0.0F , 0,(float)x, 0);
+        }
+
+		return (long int) x;
+    }
+
+
+    val_2p23.u32 = (checkbits.u32 & 0x80000000) | 0x4B000000;
+
+   /* Add and sub 2^23 to round the number according to the current rounding direction */
+
+    return (long int) ((x + val_2p23.f32) - val_2p23.f32);
+}
diff --git a/src/lround.c b/src/lround.c
new file mode 100644
index 0000000..dfe411d
--- /dev/null
+++ b/src/lround.c
@@ -0,0 +1,135 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifdef WIN64
+#include <fpieee.h>
+#else
+#include <errno.h>
+#endif
+
+#include <math.h>
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#include "../inc/libm_special.h"
+
+long int FN_PROTOTYPE(lround)(double d)
+{
+    UT64 u64d;
+    UT64 u64Temp,u64result;
+    int intexp, shift;
+    U64 sign;
+    long int result;
+
+    u64d.f64 = u64Temp.f64 = d;
+
+    if ((u64d.u32[1] & 0X7FF00000) == 0x7FF00000)
+    {
+        /*else the number is infinity*/
+        //Raise range or domain error
+        #ifdef WIN64
+            __amd_handle_error(DOMAIN, EDOM, "lround", d, 0.0 , (double)SIGNBIT_SP32);
+			return (long int )SIGNBIT_SP32;
+        #else
+            __amd_handle_error(DOMAIN, EDOM, "lround", d, 0.0 , (double)SIGNBIT_DP64);
+			return SIGNBIT_DP64; /*GCC returns this when the number is out of range*/
+        #endif
+
+    }
+
+    u64Temp.u32[1] &= 0x7FFFFFFF;
+    intexp = (u64d.u32[1] & 0x7FF00000) >> 20;
+    sign = u64d.u64 & 0x8000000000000000;
+    intexp -= 0x3FF;
+
+    /* 1.0 x 2^-1 is the smallest number which can be rounded to 1 */
+    if (intexp < -1)
+        return (0);
+
+#ifdef WIN64
+    /* 1.0 x 2^31 (or 2^63) is already too large */
+    if (intexp >= 31)
+    {
+        /*Based on the sign of the input value return the MAX and MIN*/
+        result = 0x80000000; /*Return LONG MIN*/
+        
+        __amd_handle_error(DOMAIN, EDOM, "lround", d, 0.0 , (double) result);
+
+        return result;
+    }
+
+
+#else
+    /* 1.0 x 2^31 (or 2^63) is already too large */
+    if (intexp >= 63)
+    {
+        /*Based on the sign of the input value return the MAX and MIN*/
+        result = 0x8000000000000000; /*Return LONG MIN*/
+            
+        __amd_handle_error(DOMAIN, EDOM, "lround", d, 0.0 , (double) result);
+
+        return result;
+    }
+
+#endif
+
+    u64result.f64 = u64Temp.f64;
+    /* >= 2^52 is already an exact integer */
+#ifdef WIN64
+    if (intexp < 23)
+#else
+    if (intexp < 52)
+#endif
+    {
+        /* add 0.5, extraction below will truncate */
+        u64result.f64 = u64Temp.f64 + 0.5;
+    }
+
+    intexp = ((u64result.u32[1] >> 20) & 0x7ff) - 0x3FF;
+
+    u64result.u32[1] &= 0xfffff;
+    u64result.u32[1] |= 0x00100000; /*Mask the last exp bit to 1*/
+    shift = intexp - 52;
+
+#ifdef WIN64
+	/*The shift value will always be negative.*/
+    u64result.u64 = u64result.u64 >> (-shift);
+	/*Result will be stored in the lower word due to the shift being performed*/
+    result = u64result.u32[0];
+#else
+     if(shift < 0)
+        u64result.u64 = u64result.u64 >> (-shift);
+    if(shift > 0)
+        u64result.u64 = u64result.u64 << (shift);
+
+    result = u64result.u64;
+#endif
+
+
+
+    if (sign)
+        result = -result;
+
+    return result;
+}
+
diff --git a/src/lroundf.c b/src/lroundf.c
new file mode 100644
index 0000000..799e960
--- /dev/null
+++ b/src/lroundf.c
@@ -0,0 +1,147 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifdef WIN64
+#include <fpieee.h>
+#else
+#include <errno.h>
+#endif
+
+#include <math.h>
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#include "../inc/libm_special.h"
+
+long int FN_PROTOTYPE(lroundf)(float f)
+{
+    UT32 u32d;
+    UT32 u32Temp,u32result;
+    int intexp, shift;
+    U32 sign;
+    long int  result;
+
+    u32d.f32 = u32Temp.f32 = f;
+    if ((u32d.u32 & 0X7F800000) == 0x7F800000)
+    {
+        /*else the number is infinity*/
+		//Raise range or domain error
+        {
+            unsigned int is_x_snan;
+            UT32 xm; xm.f32 = f;
+            is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+		#ifdef WIN64
+            __amd_handle_errorf(DOMAIN, EDOM, "lroundf", f, is_x_snan, 0.0F , 0,(float)SIGNBIT_SP32, 0);
+			return (long int)SIGNBIT_SP32;
+		#else
+            __amd_handle_errorf(DOMAIN, EDOM, "lroundf", f, is_x_snan, 0.0F , 0,(float)SIGNBIT_DP64, 0);
+			return SIGNBIT_DP64; /*GCC returns this when the number is out of range*/
+		#endif
+        }
+
+    }
+
+    u32Temp.u32 &= 0x7FFFFFFF;
+    intexp = (u32d.u32 & 0x7F800000) >> 23;
+    sign = u32d.u32 & 0x80000000;
+    intexp -= 0x7F;
+
+
+    /* 1.0 x 2^-1 is the smallest number which can be rounded to 1 */
+    if (intexp < -1)
+        return (0);
+
+
+#ifdef WIN64
+    /* 1.0 x 2^31 is already too large */
+    if (intexp >= 31)
+    {
+        result = 0x80000000;
+
+        {
+            unsigned int is_x_snan;
+            UT32 xm; xm.f32 = f;
+            is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+            __amd_handle_errorf(DOMAIN, EDOM, "lroundf", f, is_x_snan, 0.0F , 0,(float)result, 0);
+        }
+
+        return result;
+	}
+
+#else
+    /* 1.0 x 2^31 (or 2^63) is already too large */
+    if (intexp >= 63)
+    {
+        result = 0x8000000000000000;
+            
+        {
+            unsigned int is_x_snan;
+            UT32 xm; xm.f32 = f;
+            is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+            __amd_handle_errorf(DOMAIN, EDOM, "lroundf", f, is_x_snan, 0.0F , 0,(float)result, 0);
+        }
+
+        return result;
+    }
+ #endif
+
+    u32result.f32 = u32Temp.f32;
+
+    /* >= 2^23 is already an exact integer */
+    if (intexp < 23)
+    {
+        /* add 0.5, extraction below will truncate */
+        u32result.f32 = u32Temp.f32 + 0.5F;
+    }
+    intexp = (u32result.u32 & 0x7f800000) >> 23;
+    intexp -= 0x7f;
+    u32result.u32 &= 0x7fffff;
+    u32result.u32 |= 0x00800000;
+
+    result = u32result.u32;
+
+    #ifdef WIN64
+    shift = intexp - 23;
+    #else
+
+    /*Since float is only 32 bit for higher accuracy we shift the result by 32 bits
+     * In the next step we shift an extra 32 bits in the reverse direction based
+     * on the value of intexp*/
+    result = result << 32;
+    shift = intexp - 55; /*55= 23 +32*/
+    #endif
+
+
+	if(shift < 0)
+		result = result >> (-shift);
+	if(shift > 0)
+        result = result << (shift);
+
+    if (sign)
+        result = -result;
+    return result;
+
+}
+
+
+
diff --git a/src/modf.c b/src/modf.c
new file mode 100644
index 0000000..836db46
--- /dev/null
+++ b/src/modf.c
@@ -0,0 +1,80 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+double FN_PROTOTYPE(modf)(double x, double *iptr)
+{
+  /* modf splits the argument x into integer and fraction parts,
+     each with the same sign as x. */
+
+
+  long long xexp;
+  unsigned long long ux, ax, mask;
+
+  GET_BITS_DP64(x, ux);
+  ax = ux & (~SIGNBIT_DP64);
+
+  if (ax >= 0x4340000000000000)
+    {
+      /* abs(x) is either NaN, infinity, or >= 2^53 */
+      if (ax > 0x7ff0000000000000)
+        {
+          /* x is NaN */
+          *iptr = x;
+          return x + x; /* Raise invalid if it is a signalling NaN */
+        }
+      else
+        {
+          /* x is infinity or large. Return zero with the sign of x */
+          *iptr = x;
+          PUT_BITS_DP64(ux & SIGNBIT_DP64, x);
+          return x;
+        }
+    }
+  else if (ax < 0x3ff0000000000000)
+    {
+      /* abs(x) < 1.0. Set iptr to zero with the sign of x
+         and return x. */
+      PUT_BITS_DP64(ux & SIGNBIT_DP64, *iptr);
+      return x;
+    }
+  else
+    {
+      double r;
+      unsigned long long ur;
+      xexp = ((ux & EXPBITS_DP64) >> EXPSHIFTBITS_DP64) - EXPBIAS_DP64;
+      /* Mask out the bits of x that we don't want */
+      mask = 1;
+      mask = (mask << (EXPSHIFTBITS_DP64 - xexp)) - 1;
+      PUT_BITS_DP64(ux & ~mask, *iptr);
+      r = x - *iptr;
+      GET_BITS_DP64(r, ur);
+      PUT_BITS_DP64(((ux & SIGNBIT_DP64)|ur), r);
+      return r;
+    }
+
+}
+
+weak_alias (__modf, modf)
diff --git a/src/modff.c b/src/modff.c
new file mode 100644
index 0000000..7e5eae7
--- /dev/null
+++ b/src/modff.c
@@ -0,0 +1,74 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+float FN_PROTOTYPE(modff)(float x, float *iptr)
+{
+  /* modff splits the argument x into integer and fraction parts,
+     each with the same sign as x. */
+
+  unsigned int ux, mask;
+  int xexp;
+
+  GET_BITS_SP32(x, ux);
+  xexp = ((ux & (~SIGNBIT_SP32)) >> EXPSHIFTBITS_SP32) - EXPBIAS_SP32;
+
+  if (xexp < 0)
+    {
+      /* abs(x) < 1.0. Set iptr to zero with the sign of x
+         and return x. */
+      PUT_BITS_SP32(ux & SIGNBIT_SP32, *iptr);
+      return x;
+    }
+  else if (xexp < EXPSHIFTBITS_SP32)
+    {
+      float r;
+      unsigned int ur;
+      /* x lies between 1.0 and 2**(24) */
+      /* Mask out the bits of x that we don't want */
+      mask = (1 << (EXPSHIFTBITS_SP32 - xexp)) - 1;
+      PUT_BITS_SP32(ux & ~mask, *iptr);
+      r = x - *iptr;
+      GET_BITS_SP32(r, ur);
+      PUT_BITS_SP32(((ux & SIGNBIT_SP32)|ur), r);
+      return r;
+    }
+  else if ((ux & (~SIGNBIT_SP32)) > 0x7f800000)
+    {
+      /* x is NaN */
+      *iptr = x;
+      return x + x; /* Raise invalid if it is a signalling NaN */
+    }
+  else
+    {
+      /* x is infinity or large. Set iptr to x and return zero
+         with the sign of x. */
+      *iptr = x;
+      PUT_BITS_SP32(ux & SIGNBIT_SP32, x);
+      return x;
+    }
+}
+
+weak_alias (__modff, modff)
diff --git a/src/nan.c b/src/nan.c
new file mode 100644
index 0000000..fbfc52c
--- /dev/null
+++ b/src/nan.c
@@ -0,0 +1,114 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+#include <stdio.h>
+
+double  FN_PROTOTYPE(nan)(const char *tagp)
+{
+
+
+    /* Check for input range */
+    UT64 checkbits;
+    U64 val=0;
+    S64 num;
+    checkbits.u64  =QNANBITPATT_DP64; 
+    if(tagp == NULL)
+    {
+      return checkbits.f64;
+    }
+
+    switch(*tagp)
+    {
+    case '0': /* base 8 */
+                tagp++; 
+                if( *tagp == 'x' || *tagp == 'X')
+                {
+                    /* base 16 */
+                    tagp++;
+                    while(*tagp != '\0')
+                    {
+                        
+                        if(*tagp >= 'A' && *tagp <= 'F' )
+                        {
+                            num = *tagp - 'A' + 10;
+                        }
+                        else
+                        if(*tagp >= 'a' && *tagp <= 'f' )
+                        {                          
+                            num = *tagp - 'a' + 10;  
+                        }
+                        else
+                        {
+                            num = *tagp - '0'; 
+                        }                        
+
+                        if( (num < 0 || num > 15))
+                        {
+                            val = QNANBITPATT_DP64;
+                            break;
+                        }
+                        val = (val << 4)  |  num; 
+                        tagp++;
+                    }
+                }
+                else
+                {
+                    /* base 8 */
+                    while(*tagp != '\0')
+                    {
+                        num = *tagp - '0';
+                        if( num < 0 || num > 7)
+                        {
+                            val = QNANBITPATT_DP64;
+                            break;
+                        }
+                        val = (val << 3)  |  num; 
+                        tagp++;
+                    }
+                }
+		break;
+    default:
+                while(*tagp != '\0')
+                {
+                    val = val*10;
+                    num = *tagp - '0';
+                    if( num < 0 || num > 9)
+                    {
+                        val = QNANBITPATT_DP64;
+                        break;
+                    }
+                    val = val + num; 
+                    tagp++;
+                }
+            
+    }
+
+   if((val & ~NINFBITPATT_DP64) == 0)
+	val = QNANBITPATT_DP64;
+	 
+    checkbits.u64 = (val | QNANBITPATT_DP64) & ~SIGNBIT_DP64;
+    return checkbits.f64  ;
+}
+
diff --git a/src/nanf.c b/src/nanf.c
new file mode 100644
index 0000000..8d712f2
--- /dev/null
+++ b/src/nanf.c
@@ -0,0 +1,120 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+#include <stdio.h>
+
+
+float  FN_PROTOTYPE(nanf)(const char *tagp)
+{
+
+
+    /* Check for input range */
+    UT32 checkbits;
+    U32 val=0;
+    S32 num;
+    checkbits.u32  =QNANBITPATT_SP32; 
+    if(tagp == NULL)
+      return  checkbits.f32 ;
+      
+
+    switch(*tagp)
+    {
+    case '0': /* base 8 */
+                tagp++; 
+                if( *tagp == 'x' || *tagp == 'X')
+                {
+                    /* base 16 */
+                    tagp++;
+                    while(*tagp != '\0')
+                    {
+                        
+                        if(*tagp >= 'A' && *tagp <= 'F' )
+                        {
+                            num = *tagp - 'A' + 10;
+                        }
+                        else
+                        if(*tagp >= 'a' && *tagp <= 'f' )
+                        {                          
+                            num = *tagp - 'a' + 10;  
+                        }
+                        else
+                        {
+                            num = *tagp - '0'; 
+                        }                        
+
+                        if( (num < 0 || num > 15))
+                        {
+                            val = QNANBITPATT_SP32;
+                            break;
+                        }
+                        val = (val << 4)  |  num; 
+                        tagp++;
+                    }
+                }
+                else
+                {
+                    /* base 8 */
+                    while(*tagp != '\0')
+                    {
+                        num = *tagp - '0';
+                        if( num < 0 || num > 7)
+                        {
+                            val = QNANBITPATT_SP32;
+                            break;
+                        }
+                        val = (val << 3)  |  num; 
+                        tagp++;
+                    }
+                }
+		break;
+    default:
+                while(*tagp != '\0')
+                {
+                    val = val*10;
+                    num = *tagp - '0';
+                    if( num < 0 || num > 9)
+                    {
+                        val = QNANBITPATT_SP32;
+                        break;
+                    }
+                    val = val + num; 
+                    tagp++;
+                }
+            
+    }
+     
+/*   if(val > ~INDEFBITPATT_SP32)
+	val = (val | QNANBITPATT_SP32) & ~SIGNBIT_SP32;
+	 
+    checkbits.u32 = val | EXPBITS_SP32 ;	 */
+
+   if((val & ~INDEFBITPATT_SP32) == 0)
+	val = QNANBITPATT_SP32;
+	 
+    checkbits.u32 = (val | QNANBITPATT_SP32) & ~SIGNBIT_SP32;
+
+
+	return checkbits.f32  ;
+}
diff --git a/src/nearbyintf.c b/src/nearbyintf.c
new file mode 100644
index 0000000..2b656ef
--- /dev/null
+++ b/src/nearbyintf.c
@@ -0,0 +1,51 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+
+float FN_PROTOTYPE(nearbyintf)(float x)
+{
+    /* Check for input range */
+    UT32 checkbits,sign,val_2p23;
+    checkbits.f32=x;
+
+    /* Clear the sign bit and check if the value can be rounded(i.e check if exponent less than 23) */
+    if( (checkbits.u32 & 0x7FFFFFFF) > 0x4B000000)
+    {
+      /* take care of nan or inf */
+      if((checkbits.u32 & 0x7f800000)== 0x7f800000)
+          return x+x;
+      else
+          return x;
+    }
+
+    sign.u32 =  checkbits.u32 & 0x80000000;   
+    val_2p23.u32 = sign.u32 | 0x4B000000;
+    val_2p23.f32 = (x + val_2p23.f32) - val_2p23.f32;
+    /*This extra line is to take care of denormals and various rounding modes*/
+    val_2p23.u32 = ((val_2p23.u32 << 1) >> 1) | sign.u32;
+    return (val_2p23.f32);   
+}
+
diff --git a/src/nextafter.c b/src/nextafter.c
new file mode 100644
index 0000000..62d9b5a
--- /dev/null
+++ b/src/nextafter.c
@@ -0,0 +1,91 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifdef WIN64
+#include <fpieee.h>
+#endif
+
+#include <float.h>
+#include <math.h>
+#include <errno.h>
+#include <limits.h>
+
+#include "libm_amd.h"
+#include "libm_util_amd.h"
+#include "libm_special.h"
+
+
+
+
+double FN_PROTOTYPE(nextafter)(double x, double y)
+{
+
+
+    UT64 checkbits;
+    double dy = y;
+    checkbits.f64=x;
+
+    /* if x == y return y in the type of x */
+    if( x == dy )
+    {
+        return dy;
+    }
+
+    /* check if the number is nan */
+    if(((checkbits.u64 & ~SIGNBIT_DP64) >= EXPBITS_DP64 ))
+    {
+		__amd_handle_error(DOMAIN, ERANGE, "nextafter", x, y , x+x);
+
+        return x+x;
+    }
+
+    if( x == 0.0)
+    {
+        checkbits.u64 = 1;
+        if( dy > 0.0 )
+             return checkbits.f64;
+        else
+            return -checkbits.f64;
+    }
+
+
+    /* compute the next heigher or lower value */
+
+    if(((x>0.0) ^ (dy>x)) == 0)
+    {
+        checkbits.u64++;
+    }
+    else
+    {
+        checkbits.u64--;
+    }
+
+    /* check if the result is nan or inf */
+    if(((checkbits.u64 & ~SIGNBIT_DP64) >= EXPBITS_DP64 ))
+    {
+		__amd_handle_error(DOMAIN, ERANGE, "nextafter", x, y , checkbits.f64);
+
+    }
+
+    return checkbits.f64;
+}
diff --git a/src/nextafterf.c b/src/nextafterf.c
new file mode 100644
index 0000000..019187f
--- /dev/null
+++ b/src/nextafterf.c
@@ -0,0 +1,102 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifdef WIN64
+#include <fpieee.h>
+#endif
+
+
+#include <float.h>
+#include <math.h>
+#include <errno.h>
+#include <limits.h>
+
+#include "libm_amd.h"
+#include "libm_util_amd.h"
+#include "libm_special.h"
+
+
+
+
+float FN_PROTOTYPE(nextafterf)(float x, float y)
+{
+
+
+    UT32 checkbits;
+    float dy = y;
+    checkbits.f32=x;
+
+    /* if x == y return y in the type of x */
+    if( x == dy )
+    {
+        return  dy;
+    }
+
+    /* check if the number is nan */
+    if(((checkbits.u32 & ~SIGNBIT_SP32) >= EXPBITS_SP32 ))
+    {
+        {
+            unsigned int is_x_snan;
+            UT32 xm; xm.f32 = x;
+            is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+            __amd_handle_errorf(DOMAIN, ERANGE, "nextafterf", x, is_x_snan, y , 0,x+x, 0);
+
+        }
+
+        return x+x;
+    }
+
+    if( x == 0.0)
+    {
+        checkbits.u32 = 1;
+        if( dy > 0.0 )
+             return checkbits.f32;
+        else
+            return -checkbits.f32;
+    }
+
+
+    /* compute the next heigher or lower value */
+    if(((x>0.0F) ^ (dy>x)) == 0)
+    {
+        checkbits.u32++;
+    }
+    else
+    {
+        checkbits.u32--;
+    }
+
+    /* check if the result is nan or inf */
+    if(((checkbits.u32 & ~SIGNBIT_SP32) >= EXPBITS_SP32 ))
+    {
+        {
+            unsigned int is_x_snan;
+            UT32 xm; xm.f32 = x;
+            is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+            __amd_handle_errorf(DOMAIN, ERANGE, "nextafterf", x, is_x_snan, y , 0,checkbits.f32, 0);
+
+        }
+    }
+
+    return checkbits.f32;
+}
diff --git a/src/nexttoward.c b/src/nexttoward.c
new file mode 100644
index 0000000..14b2f62
--- /dev/null
+++ b/src/nexttoward.c
@@ -0,0 +1,93 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifdef WIN64
+#include <fpieee.h>
+#else
+#include <errno.h>
+#endif
+
+#include <math.h>
+
+#include "libm_amd.h"
+#include "libm_util_amd.h"
+#include "libm_special.h"
+
+
+
+
+double FN_PROTOTYPE(nexttoward)(double x, long double y)
+{
+
+
+    UT64 checkbits;
+    long double dy = (long double) y;
+    checkbits.f64=x;
+
+    /* if x == y return y in the type of x */
+    if( x == dy )
+    {
+        return (double) dy;
+    }
+
+    /* check if the number is nan */
+    if(((checkbits.u64 & ~SIGNBIT_DP64) >= EXPBITS_DP64 ))
+    {
+
+		__amd_handle_error(DOMAIN, ERANGE, "nexttoward", x, (double)y ,x+x);
+
+
+        return x+x;
+    }
+
+    if( x == 0.0)
+    {
+        checkbits.u64 = 1;
+        if( dy > 0.0 )
+             return checkbits.f64;
+        else
+            return -checkbits.f64;
+    }
+
+
+    /* compute the next heigher or lower value */
+
+    if(((x>0.0) ^ (dy>x)) == 0)
+    {
+        checkbits.u64++;
+    }
+    else
+    {
+        checkbits.u64--;
+    }
+
+    /* check if the result is nan or inf */
+    if(((checkbits.u64 & ~SIGNBIT_DP64) >= EXPBITS_DP64 ))
+    {
+		__amd_handle_error(DOMAIN, ERANGE, "nexttoward", x, (double)y ,checkbits.f64);
+
+
+    }
+
+    return checkbits.f64;
+}
diff --git a/src/nexttowardf.c b/src/nexttowardf.c
new file mode 100644
index 0000000..47b42c7
--- /dev/null
+++ b/src/nexttowardf.c
@@ -0,0 +1,97 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifdef WIN64
+#include <fpieee.h>
+#else
+#include <errno.h>
+#endif
+
+#include <math.h>
+
+#include "libm_amd.h"
+#include "libm_util_amd.h"
+#include "libm_special.h"
+
+
+float FN_PROTOTYPE(nexttowardf)(float x, long double y)
+{
+
+
+    UT32 checkbits;
+    long double dy = (long double) y;
+    checkbits.f32=x;
+
+    /* if x == y return y in the type of x */
+    if( x == dy )
+    {
+        return (float) dy;
+    }
+
+    /* check if the number is nan */
+    if(((checkbits.u32 & ~SIGNBIT_SP32) >= EXPBITS_SP32 ))
+    {
+        {
+            unsigned int is_x_snan;
+            UT32 xm; xm.f32 = x;
+            is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+            __amd_handle_errorf(DOMAIN, ERANGE, "nexttowardf", x, is_x_snan, (float) y , 0,x+x, 0);
+
+        }
+
+        return x+x;
+    }
+
+    if( x == 0.0)
+    {
+        checkbits.u32 = 1;
+        if( dy > 0.0 )
+             return checkbits.f32;
+        else
+            return -checkbits.f32;
+    }
+
+
+    /* compute the next heigher or lower value */
+    if(((x>0.0F) ^ (dy>x)) == 0)
+    {
+        checkbits.u32++;
+    }
+    else
+    {
+        checkbits.u32--;
+    }
+
+    /* check if the result is nan or inf */
+    if(((checkbits.u32 & ~SIGNBIT_SP32) >= EXPBITS_SP32 ))
+    {
+        {
+            unsigned int is_x_snan;
+            UT32 xm; xm.f32 = x;
+            is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+            __amd_handle_errorf(DOMAIN, ERANGE, "nexttowardf", x, is_x_snan, (float) y , 0,checkbits.f32, 0);
+        }
+    }
+
+    return checkbits.f32;
+}
diff --git a/src/pow_special.c b/src/pow_special.c
new file mode 100644
index 0000000..cb571d2
--- /dev/null
+++ b/src/pow_special.c
@@ -0,0 +1,168 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+#ifdef __x86_64__
+
+#include <emmintrin.h>
+#include <math.h>
+#include <errno.h>
+
+
+
+#include "../inc/libm_util_amd.h"
+#include "../inc/libm_special.h"
+
+// these codes and the ones in the related .S or .asm files have to match
+#define POW_X_ONE_Y_SNAN            1
+#define POW_X_ZERO_Z_INF            2
+#define POW_X_NAN                   3
+#define POW_Y_NAN                   4
+#define POW_X_NAN_Y_NAN             5
+#define POW_X_NEG_Y_NOTINT          6
+#define POW_Z_ZERO                  7
+#define POW_Z_DENORMAL              8
+#define POW_Z_INF                   9
+
+float _powf_special(float x, float y, float z, U32 code)
+{
+    switch(code)
+    {
+    case POW_X_ONE_Y_SNAN:
+        {
+            _mm_setcsr(_mm_getcsr() | MXCSR_ES_INVALID);
+        }
+        break;
+
+    case POW_X_ZERO_Z_INF:
+        {
+            _mm_setcsr(_mm_getcsr() | MXCSR_ES_DIVBYZERO);
+            __amd_handle_errorf(SING, ERANGE, "powf", x, 0, y, 0, z, 0);
+        }
+        break;
+
+    case POW_X_NAN:
+    case POW_Y_NAN:
+    case POW_X_NAN_Y_NAN:
+        {
+#ifdef WIN64
+            unsigned int is_x_snan = 0, is_y_snan = 0, is_z_snan = 0;
+            UT32 xm, ym, zm;
+            xm.f32 = x;
+            ym.f32 = y;
+            zm.f32 = z;
+            if(code == POW_X_NAN) { is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 ); }
+            if(code == POW_Y_NAN) { is_y_snan = ( ((ym.u32 & QNAN_MASK_32) == 0) ? 1 : 0 ); }
+            if(code == POW_X_NAN_Y_NAN) {   is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+                                            is_y_snan = ( ((ym.u32 & QNAN_MASK_32) == 0) ? 1 : 0 ); }
+            is_z_snan = ( ((zm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+
+            _mm_setcsr(_mm_getcsr() | MXCSR_ES_INVALID);
+            __amd_handle_errorf(DOMAIN, EDOM, "powf", x, is_x_snan, y, is_y_snan, z, is_z_snan);            
+#else
+            _mm_setcsr(_mm_getcsr() | MXCSR_ES_INVALID);
+#endif
+        }
+        break;
+
+    case POW_X_NEG_Y_NOTINT:
+        {
+            _mm_setcsr(_mm_getcsr() | MXCSR_ES_INVALID);
+            __amd_handle_errorf(DOMAIN, EDOM, "powf", x, 0, y, 0, z, 0);
+        }
+        break;
+
+    case POW_Z_ZERO:
+        {
+            _mm_setcsr(_mm_getcsr() | (MXCSR_ES_INEXACT|MXCSR_ES_UNDERFLOW));
+            __amd_handle_errorf(UNDERFLOW, ERANGE, "powf", x, 0, y, 0, z, 0);
+        }
+        break;
+
+    case POW_Z_INF:
+        {
+            _mm_setcsr(_mm_getcsr() | (MXCSR_ES_INEXACT|MXCSR_ES_OVERFLOW));
+            __amd_handle_errorf(OVERFLOW, ERANGE, "powf", x, 0, y, 0, z, 0);
+        }
+        break;
+    }
+
+    return z;
+}
+
+double _pow_special(double x, double y, double z, U32 code)
+{
+    switch(code)
+    {
+    case POW_X_ONE_Y_SNAN:
+        {
+#ifdef WIN64
+#else
+            _mm_setcsr(_mm_getcsr() | MXCSR_ES_INVALID);
+#endif
+        }
+        break;
+
+    case POW_X_ZERO_Z_INF:
+        {
+            _mm_setcsr(_mm_getcsr() | MXCSR_ES_DIVBYZERO);
+            __amd_handle_error(SING, ERANGE, "pow", x, y, z);
+        }
+        break;
+
+    case POW_X_NAN:
+    case POW_Y_NAN:
+    case POW_X_NAN_Y_NAN:
+        {
+            _mm_setcsr(_mm_getcsr() | MXCSR_ES_INVALID);
+#ifdef WIN64
+            __amd_handle_error(DOMAIN, EDOM, "pow", x, y, z);
+#endif
+        }
+        break;
+
+    case POW_X_NEG_Y_NOTINT:
+        {
+            _mm_setcsr(_mm_getcsr() | MXCSR_ES_INVALID);
+            __amd_handle_error(DOMAIN, EDOM, "pow", x, y, z);
+        }
+        break;
+
+    case POW_Z_ZERO:
+    case POW_Z_DENORMAL:
+        {
+            _mm_setcsr(_mm_getcsr() | (MXCSR_ES_INEXACT|MXCSR_ES_UNDERFLOW));
+            __amd_handle_error(UNDERFLOW, ERANGE, "pow", x, y, z);
+        }
+        break;
+
+    case POW_Z_INF:
+        {
+            _mm_setcsr(_mm_getcsr() | (MXCSR_ES_INEXACT|MXCSR_ES_OVERFLOW));
+            __amd_handle_error(OVERFLOW, ERANGE, "pow", x, y, z);
+        }
+        break;
+    }
+
+    return z;
+}
+
+#endif /* __x86_64__ */
diff --git a/src/remainder_piby2.c b/src/remainder_piby2.c
new file mode 100644
index 0000000..3f6676f
--- /dev/null
+++ b/src/remainder_piby2.c
@@ -0,0 +1,331 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+
+#define EXPBITS_DP64      0x7ff0000000000000
+#define EXPSHIFTBITS_DP64 52
+#define EXPBIAS_DP64      1023
+#define MANTBITS_DP64     0x000fffffffffffff
+#define IMPBIT_DP64       0x0010000000000000
+#define SIGNBIT_DP64      0x8000000000000000
+
+
+#define GET_BITS_DP64(x, ux) \
+  { \
+    volatile union {double d; unsigned long long i;} _bitsy; \
+    _bitsy.d = (x); \
+    ux = _bitsy.i; \
+  }
+
+#define PUT_BITS_DP64(ux, x) \
+  { \
+    volatile union {double d; unsigned long long i;} _bitsy; \
+    _bitsy.i = (ux); \
+    x = _bitsy.d; \
+  }
+
+/* Define this to get debugging print statements activated */
+#define DEBUGGING_PRINT
+#undef DEBUGGING_PRINT
+
+
+#ifdef DEBUGGING_PRINT
+#include <stdio.h>
+char *d2b(int d, int bitsper, int point)
+{
+  static char buff[50];
+  int i, j;
+  j = bitsper;
+  if (point >= 0 && point <= bitsper)
+    j++;
+  buff[j] = '\0';
+  for (i = bitsper - 1; i >= 0; i--)
+    {
+      j--;
+      if (d % 2 == 1)
+        buff[j] = '1';
+      else
+        buff[j] = '0';
+      if (i == point)
+        {
+          j--;
+          buff[j] = '.';
+        }
+      d /= 2;
+    }
+  return buff;
+}
+#endif
+
+/* Given positive argument x, reduce it to the range [-pi/4,pi/4] using
+   extra precision, and return the result in r, rr.
+   Return value "region" tells how many lots of pi/2 were subtracted
+   from x to put it in the range [-pi/4,pi/4], mod 4. */
+void __amd_remainder_piby2(double x, double *r, double *rr, int *region)
+{
+
+      /* This method simulates multi-precision floating-point
+         arithmetic and is accurate for all 1 <= x < infinity */
+      static const double
+        piby2_lead = 1.57079632679489655800e+00, /* 0x3ff921fb54442d18 */
+        piby2_part1 = 1.57079631090164184570e+00, /* 0x3ff921fb50000000 */
+        piby2_part2 = 1.58932547122958567343e-08, /* 0x3e5110b460000000 */
+        piby2_part3 = 6.12323399573676480327e-17; /* 0x3c91a62633145c06 */
+      const int bitsper = 10;
+      unsigned long long res[500];
+      unsigned long long ux, u, carry, mask, mant, highbitsrr;
+      int first, last, i, rexp, xexp, resexp, ltb, determ;
+      double xx, t;
+      static unsigned long long pibits[] =
+      {
+        0,    0,    0,    0,    0,    0,
+        162,  998,   54,  915,  580,   84,  671,  777,  855,  839,
+        851,  311,  448,  877,  553,  358,  316,  270,  260,  127,
+        593,  398,  701,  942,  965,  390,  882,  283,  570,  265,
+        221,  184,    6,  292,  750,  642,  465,  584,  463,  903,
+        491,  114,  786,  617,  830,  930,   35,  381,  302,  749,
+        72,  314,  412,  448,  619,  279,  894,  260,  921,  117,
+        569,  525,  307,  637,  156,  529,  504,  751,  505,  160,
+        945, 1022,  151, 1023,  480,  358,   15,  956,  753,   98,
+        858,   41,  721,  987,  310,  507,  242,  498,  777,  733,
+        244,  399,  870,  633,  510,  651,  373,  158,  940,  506,
+        997,  965,  947,  833,  825,  990,  165,  164,  746,  431,
+        949, 1004,  287,  565,  464,  533,  515,  193,  111,  798
+      };
+
+      GET_BITS_DP64(x, ux);
+
+#ifdef DEBUGGING_PRINT
+      printf("On entry, x = %25.20e = %s\n", x, double2hex(&x));
+#endif
+
+      xexp = (int)(((ux & EXPBITS_DP64) >> EXPSHIFTBITS_DP64) - EXPBIAS_DP64);
+      ux = (ux & MANTBITS_DP64) | IMPBIT_DP64;
+
+      /* Now ux is the mantissa bit pattern of x as a long integer */
+      carry = 0;
+      mask = 1;
+      mask = (mask << bitsper) - 1;
+
+      /* Set first and last to the positions of the first
+         and last chunks of 2/pi that we need */
+      first = xexp / bitsper;
+      resexp = xexp - first * bitsper;
+      /* 180 is the theoretical maximum number of bits (actually
+         175 for IEEE double precision) that we need to extract
+         from the middle of 2/pi to compute the reduced argument
+         accurately enough for our purposes */
+      last = first + 180 / bitsper;
+
+      /* Do a long multiplication of the bits of 2/pi by the
+         integer mantissa */
+      /* Unroll the loop. This is only correct because we know
+         that bitsper is fixed as 10. */
+      res[19] = 0;
+      u = pibits[last] * ux;
+      res[18] = u & mask;
+      carry = u >> bitsper;
+      u = pibits[last-1] * ux + carry;
+      res[17] = u & mask;
+      carry = u >> bitsper;
+      u = pibits[last-2] * ux + carry;
+      res[16] = u & mask;
+      carry = u >> bitsper;
+      u = pibits[last-3] * ux + carry;
+      res[15] = u & mask;
+      carry = u >> bitsper;
+      u = pibits[last-4] * ux + carry;
+      res[14] = u & mask;
+      carry = u >> bitsper;
+      u = pibits[last-5] * ux + carry;
+      res[13] = u & mask;
+      carry = u >> bitsper;
+      u = pibits[last-6] * ux + carry;
+      res[12] = u & mask;
+      carry = u >> bitsper;
+      u = pibits[last-7] * ux + carry;
+      res[11] = u & mask;
+      carry = u >> bitsper;
+      u = pibits[last-8] * ux + carry;
+      res[10] = u & mask;
+      carry = u >> bitsper;
+      u = pibits[last-9] * ux + carry;
+      res[9] = u & mask;
+      carry = u >> bitsper;
+      u = pibits[last-10] * ux + carry;
+      res[8] = u & mask;
+      carry = u >> bitsper;
+      u = pibits[last-11] * ux + carry;
+      res[7] = u & mask;
+      carry = u >> bitsper;
+      u = pibits[last-12] * ux + carry;
+      res[6] = u & mask;
+      carry = u >> bitsper;
+      u = pibits[last-13] * ux + carry;
+      res[5] = u & mask;
+      carry = u >> bitsper;
+      u = pibits[last-14] * ux + carry;
+      res[4] = u & mask;
+      carry = u >> bitsper;
+      u = pibits[last-15] * ux + carry;
+      res[3] = u & mask;
+      carry = u >> bitsper;
+      u = pibits[last-16] * ux + carry;
+      res[2] = u & mask;
+      carry = u >> bitsper;
+      u = pibits[last-17] * ux + carry;
+      res[1] = u & mask;
+      carry = u >> bitsper;
+      u = pibits[last-18] * ux + carry;
+      res[0] = u & mask;
+
+#ifdef DEBUGGING_PRINT
+      printf("resexp = %d\n", resexp);
+      printf("Significant part of x * 2/pi with binary"
+             " point in correct place:\n");
+      for (i = 0; i <= last - first; i++)
+        {
+          if (i > 0 && i % 5 == 0)
+            printf("\n ");
+          if (i == 1)
+            printf("%s ", d2b((int)res[i], bitsper, resexp));
+          else
+            printf("%s ", d2b((int)res[i], bitsper, -1));
+        }
+      printf("\n");
+#endif
+
+      /* Reconstruct the result */
+      ltb = (int)((((res[0] << bitsper) | res[1])
+                   >> (bitsper - 1 - resexp)) & 7);
+
+      /* determ says whether the fractional part is >= 0.5 */
+      determ = ltb & 1;
+
+#ifdef DEBUGGING_PRINT
+      printf("ltb = %d (last two bits before binary point"
+             " and first bit after)\n", ltb);
+      printf("determ = %d (1 means need to negate because the fractional\n"
+             "            part of x * 2/pi is greater than 0.5)\n", determ);
+#endif
+
+      i = 1;
+      if (determ)
+        {
+          /* The mantissa is >= 0.5. We want to subtract it
+             from 1.0 by negating all the bits */
+          *region = ((ltb >> 1) + 1) & 3;
+          mant = 1;
+          mant = ~(res[1]) & ((mant << (bitsper - resexp)) - 1);
+          while (mant < 0x0020000000000000)
+            {
+              i++;
+              mant = (mant << bitsper) | (~(res[i]) & mask);
+            }
+          highbitsrr = ~(res[i + 1]) << (64 - bitsper);
+        }
+      else
+        {
+          *region = (ltb >> 1);
+          mant = 1;
+          mant = res[1] & ((mant << (bitsper - resexp)) - 1);
+          while (mant < 0x0020000000000000)
+            {
+              i++;
+              mant = (mant << bitsper) | res[i];
+            }
+          highbitsrr = res[i + 1] << (64 - bitsper);
+        }
+
+      rexp = 52 + resexp - i * bitsper;
+
+      while (mant >= 0x0020000000000000)
+        {
+          rexp++;
+          highbitsrr = (highbitsrr >> 1) | ((mant & 1) << 63);
+          mant >>= 1;
+        }
+
+#ifdef DEBUGGING_PRINT
+      printf("Normalised mantissa = 0x%016lx\n", mant);
+      printf("High bits of rest of mantissa = 0x%016lx\n", highbitsrr);
+      printf("Exponent to be inserted on mantissa = rexp = %d\n", rexp);
+#endif
+
+      /* Put the result exponent rexp onto the mantissa pattern */
+      u = ((unsigned long long)rexp + EXPBIAS_DP64) << EXPSHIFTBITS_DP64;
+      ux = (mant & MANTBITS_DP64) | u;
+      if (determ)
+        /* If we negated the mantissa we negate x too */
+        ux |= SIGNBIT_DP64;
+      PUT_BITS_DP64(ux, x);
+
+      /* Create the bit pattern for rr */
+      highbitsrr >>= 12; /* Note this is shifted one place too far */
+      u = ((unsigned long long)rexp + EXPBIAS_DP64 - 53) << EXPSHIFTBITS_DP64;
+      PUT_BITS_DP64(u, t);
+      u |= highbitsrr;
+      PUT_BITS_DP64(u, xx);
+
+      /* Subtract the implicit bit we accidentally added */
+      xx -= t;
+      /* Set the correct sign, and double to account for the
+         "one place too far" shift */
+      if (determ)
+        xx *= -2.0;
+      else
+        xx *= 2.0;
+
+#ifdef DEBUGGING_PRINT
+      printf("(lead part of x*2/pi) = %25.20e = %s\n", x, double2hex(&x));
+      printf("(tail part of x*2/pi) = %25.20e = %s\n", xx, double2hex(&xx));
+#endif
+
+      /* (x,xx) is an extra-precise version of the fractional part of
+         x * 2 / pi. Multiply (x,xx) by pi/2 in extra precision
+         to get the reduced argument (r,rr). */
+      {
+        double hx, tx, c, cc;
+        /* Split x into hx (head) and tx (tail) */
+        GET_BITS_DP64(x, ux);
+        ux &= 0xfffffffff8000000;
+        PUT_BITS_DP64(ux, hx);
+        tx = x - hx;
+
+        c = piby2_lead * x;
+        cc = ((((piby2_part1 * hx - c) + piby2_part1 * tx) +
+               piby2_part2 * hx) + piby2_part2 * tx) +
+          (piby2_lead * xx + piby2_part3 * x);
+        *r = c + cc;
+        *rr = (c - *r) + cc;
+      }
+
+#ifdef DEBUGGING_PRINT
+      printf(" (r,rr) = lead and tail parts of frac(x*2/pi) * pi/2:\n");
+      printf(" r = %25.20e = %s\n", *r, double2hex(r));
+      printf("rr = %25.20e = %s\n", *rr, double2hex(rr));
+      printf("region = (number of pi/2 subtracted from x) mod 4 = %d\n",
+             *region);
+#endif
+  return;
+}
diff --git a/src/remainder_piby2d2f.c b/src/remainder_piby2d2f.c
new file mode 100644
index 0000000..59ed44a
--- /dev/null
+++ b/src/remainder_piby2d2f.c
@@ -0,0 +1,217 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+
+#define EXPBITS_DP64      0x7ff0000000000000
+#define EXPSHIFTBITS_DP64 52
+#define EXPBIAS_DP64      1023
+#define MANTBITS_DP64     0x000fffffffffffff
+#define IMPBIT_DP64       0x0010000000000000
+#define SIGNBIT_DP64      0x8000000000000000
+
+#define PUT_BITS_DP64(ux, x) \
+  { \
+    volatile union {double d; unsigned long long i;} _bitsy; \
+    _bitsy.i = (ux); \
+    x = _bitsy.d; \
+  }
+
+/*Derived from static inline void __amd_remainder_piby2f_inline(unsigned long long ux, double *r, int *region)
+in libm_inlines_amd.h. libm_inlines.h has the pure Windows one while libm_inlines_amd.h has the mixed one.
+*/
+/* Given positive argument x, reduce it to the range [-pi/4,pi/4] using
+   extra precision, and return the result in r.
+   Return value "region" tells how many lots of pi/2 were subtracted
+   from x to put it in the range [-pi/4,pi/4], mod 4. */
+void __amd_remainder_piby2d2f(unsigned long long ux, double *r, int *region)
+{
+	/* This method simulates multi-precision floating-point
+       arithmetic and is accurate for all 1 <= x < infinity */  
+	unsigned long long u, carry, mask, mant, highbitsrr;
+    double dx; 
+	unsigned long long res[500];
+    int first, last, i, rexp, xexp, resexp, ltb, determ;
+    static const double
+		piby2 = 1.57079632679489655800e+00; /* 0x3ff921fb54442d18 */
+    const int bitsper = 10;
+    static unsigned long long pibits[] =
+	{
+		0,    0,    0,    0,    0,    0,
+        162,  998,   54,  915,  580,   84,  671,  777,  855,  839,
+        851,  311,  448,  877,  553,  358,  316,  270,  260,  127,
+        593,  398,  701,  942,  965,  390,  882,  283,  570,  265,
+        221,  184,    6,  292,  750,  642,  465,  584,  463,  903,
+        491,  114,  786,  617,  830,  930,   35,  381,  302,  749,
+        72,  314,  412,  448,  619,  279,  894,  260,  921,  117,
+        569,  525,  307,  637,  156,  529,  504,  751,  505,  160,
+        945, 1022,  151, 1023,  480,  358,   15,  956,  753,   98,
+        858,   41,  721,  987,  310,  507,  242,  498,  777,  733,
+        244,  399,  870,  633,  510,  651,  373,  158,  940,  506,
+        997,  965,  947,  833,  825,  990,  165,  164,  746,  431,
+        949, 1004,  287,  565,  464,  533,  515,  193,  111,  798  
+	};
+  
+	xexp = (int)(((ux & EXPBITS_DP64) >> EXPSHIFTBITS_DP64) - EXPBIAS_DP64);
+    ux = (ux & MANTBITS_DP64) | IMPBIT_DP64;
+
+    /* Now ux is the mantissa bit pattern of x as a long integer */
+    mask = 1;
+    mask = (mask << bitsper) - 1;
+
+    /* Set first and last to the positions of the first
+       and last chunks of 2/pi that we need */
+    first = xexp / bitsper;
+    resexp = xexp - first * bitsper;
+    /* 180 is the theoretical maximum number of bits (actually
+       175 for IEEE double precision) that we need to extract
+       from the middle of 2/pi to compute the reduced argument
+       accurately enough for our purposes */
+    last = first + 180 / bitsper;
+
+    /* Do a long multiplication of the bits of 2/pi by the
+       integer mantissa */
+    /* Unroll the loop. This is only correct because we know
+       that bitsper is fixed as 10. */
+    res[19] = 0;
+    u = pibits[last] * ux;
+    res[18] = u & mask;
+    carry = u >> bitsper;
+    u = pibits[last-1] * ux + carry;
+    res[17] = u & mask;
+    carry = u >> bitsper;
+    u = pibits[last-2] * ux + carry;
+    res[16] = u & mask;
+    carry = u >> bitsper;
+    u = pibits[last-3] * ux + carry;
+    res[15] = u & mask;
+    carry = u >> bitsper;
+    u = pibits[last-4] * ux + carry;
+    res[14] = u & mask;
+    carry = u >> bitsper;
+    u = pibits[last-5] * ux + carry;
+    res[13] = u & mask;
+    carry = u >> bitsper;
+    u = pibits[last-6] * ux + carry;
+    res[12] = u & mask;
+    carry = u >> bitsper;
+    u = pibits[last-7] * ux + carry;
+    res[11] = u & mask;
+    carry = u >> bitsper;
+    u = pibits[last-8] * ux + carry;
+    res[10] = u & mask;
+    carry = u >> bitsper;
+    u = pibits[last-9] * ux + carry;
+    res[9] = u & mask;
+    carry = u >> bitsper;
+    u = pibits[last-10] * ux + carry;
+    res[8] = u & mask;
+    carry = u >> bitsper;
+    u = pibits[last-11] * ux + carry;
+    res[7] = u & mask;
+    carry = u >> bitsper;
+    u = pibits[last-12] * ux + carry;
+    res[6] = u & mask;
+    carry = u >> bitsper;
+    u = pibits[last-13] * ux + carry;
+    res[5] = u & mask;
+    carry = u >> bitsper;
+    u = pibits[last-14] * ux + carry;
+    res[4] = u & mask;
+    carry = u >> bitsper;
+    u = pibits[last-15] * ux + carry;
+    res[3] = u & mask;
+    carry = u >> bitsper;
+    u = pibits[last-16] * ux + carry;
+    res[2] = u & mask;
+    carry = u >> bitsper;
+    u = pibits[last-17] * ux + carry;
+    res[1] = u & mask;
+    carry = u >> bitsper;
+    u = pibits[last-18] * ux + carry;
+    res[0] = u & mask;
+
+    /* Reconstruct the result */
+    ltb = (int)((((res[0] << bitsper) | res[1])
+		>> (bitsper - 1 - resexp)) & 7);
+
+    /* determ says whether the fractional part is >= 0.5 */
+    determ = ltb & 1;
+
+    i = 1;
+    if (determ)
+    {
+		/* The mantissa is >= 0.5. We want to subtract it
+           from 1.0 by negating all the bits */
+        *region = ((ltb >> 1) + 1) & 3;
+        mant = 1;
+        mant = ~(res[1]) & ((mant << (bitsper - resexp)) - 1);
+        while (mant < 0x0020000000000000)
+        {
+            i++;
+            mant = (mant << bitsper) | (~(res[i]) & mask);
+        }
+        highbitsrr = ~(res[i + 1]) << (64 - bitsper);
+	}
+    else
+    {
+        *region = (ltb >> 1);
+        mant = 1;
+        mant = res[1] & ((mant << (bitsper - resexp)) - 1);
+        while (mant < 0x0020000000000000)
+        {
+            i++;
+            mant = (mant << bitsper) | res[i];
+        }
+        highbitsrr = res[i + 1] << (64 - bitsper);
+    }
+
+    rexp = 52 + resexp - i * bitsper;
+
+    while (mant >= 0x0020000000000000)
+    {
+        rexp++;
+        highbitsrr = (highbitsrr >> 1) | ((mant & 1) << 63);
+        mant >>= 1;
+    }
+
+    /* Put the result exponent rexp onto the mantissa pattern */
+    u = ((unsigned long long)rexp + EXPBIAS_DP64) << EXPSHIFTBITS_DP64;
+    ux = (mant & MANTBITS_DP64) | u;
+    if (determ)
+      /* If we negated the mantissa we negate x too */
+      ux |= SIGNBIT_DP64;
+    PUT_BITS_DP64(ux, dx);
+
+    /* x is a double precision version of the fractional part of
+       x * 2 / pi. Multiply x by pi/2 in double precision
+       to get the reduced argument r. */
+    *r = dx * piby2;
+
+	return;
+}
+
+void __remainder_piby2d2f(unsigned long ux, double *r, int *region)
+{
+	__amd_remainder_piby2d2f((unsigned long long) ux, r, region);
+}
+
diff --git a/src/rint.c b/src/rint.c
new file mode 100644
index 0000000..770685f
--- /dev/null
+++ b/src/rint.c
@@ -0,0 +1,69 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "libm_amd.h"
+#include "libm_util_amd.h"
+
+
+
+double FN_PROTOTYPE(rint)(double x)
+{
+
+    UT64 checkbits,val_2p52;
+	UT32 sign;
+    checkbits.f64=x;
+
+    /* Clear the sign bit and check if the value can be rounded(i.e check if exponent less than 52) */
+    if( (checkbits.u64 & 0x7FFFFFFFFFFFFFFF) > 0x4330000000000000)
+    {
+      /* take care of nan or inf */
+      if((checkbits.u32[1] & 0x7ff00000)== 0x7ff00000)
+          return x+x;
+      else
+          return x;
+    }
+
+    sign.u32 =  checkbits.u32[1] & 0x80000000;
+    val_2p52.u32[1] = sign.u32 | 0x43300000;
+    val_2p52.u32[0] = 0;
+
+	/* Add and sub 2^52 to round the number according to the current rounding direction */
+    val_2p52.f64 = (x + val_2p52.f64) - val_2p52.f64;
+
+    /*This extra line is to take care of denormals and various rounding modes*/
+    val_2p52.u32[1] = ((val_2p52.u32[1] << 1) >> 1) | sign.u32;
+
+     if(x!=val_2p52.f64)
+	{
+   	     /* Raise floating-point inexact exception if the result differs in value from the argument */
+      	    checkbits.u64 = QNANBITPATT_DP64;
+     	    checkbits.f64 = checkbits.f64 +  checkbits.f64;        /* raise inexact exception by adding two nan numbers.*/
+	}
+
+
+    return (val_2p52.f64);
+}
+
+
+
+
diff --git a/src/rintf.c b/src/rintf.c
new file mode 100644
index 0000000..e048c11
--- /dev/null
+++ b/src/rintf.c
@@ -0,0 +1,65 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "libm_amd.h"
+#include "libm_util_amd.h"
+
+
+
+float FN_PROTOTYPE(rintf)(float x)
+{
+
+    UT32 checkbits,sign,val_2p23;
+    checkbits.f32=x;
+
+    /* Clear the sign bit and check if the value can be rounded */
+    if( (checkbits.u32 & 0x7FFFFFFF) > 0x4B000000)
+    {
+      /* Number exceeds the representable range could be nan or inf also*/
+      /* take care of nan or inf */
+      if((checkbits.u32 & 0x7f800000)== 0x7f800000)
+          return x+x;
+      else
+          return x;
+    }
+
+    sign.u32 =  checkbits.u32 & 0x80000000;
+    val_2p23.u32 = (checkbits.u32 & 0x80000000) | 0x4B000000;
+
+   /* Add and sub 2^23 to round the number according to the current rounding direction */
+    val_2p23.f32  = ((x + val_2p23.f32) - val_2p23.f32);
+
+    /*This extra line is to take care of denormals and various rounding modes*/
+    val_2p23.u32 = ((val_2p23.u32 << 1) >> 1) | sign.u32;
+
+    if (val_2p23.f32 != x)
+    {
+        /* Raise floating-point inexact exception if the result differs in value from the argument */
+         checkbits.u32 = 0xFFC00000;
+         checkbits.f32 = checkbits.f32 +  checkbits.f32;        /* raise inexact exception by adding two nan numbers.*/
+    }
+
+
+    return val_2p23.f32;
+}
+
diff --git a/src/roundf.c b/src/roundf.c
new file mode 100644
index 0000000..596c381
--- /dev/null
+++ b/src/roundf.c
@@ -0,0 +1,97 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifdef WIN64
+#include <fpieee.h>
+#else
+#include <errno.h>
+#endif
+
+#include <math.h>
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+#include "../inc/libm_special.h"
+
+float FN_PROTOTYPE(roundf)(float f)
+{
+    UT32 u32f, u32Temp;
+    U32 u32sign, u32exp, u32mantissa;
+    int intexp;            /*Needs to be signed */
+    u32f.f32 = f;
+    u32sign = u32f.u32 & SIGNBIT_SP32;
+    if ((u32f.u32 & 0X7F800000) == 0x7F800000)
+    {
+        //u32f.f32 = f;
+        /*Return Quiet Nan.
+         * Quiet the signalling nan*/
+        if(!((u32f.u32 & MANTBITS_SP32) == 0))
+            u32f.u32 |= QNAN_MASK_32;
+        /*else the number is infinity*/
+        //Raise range or domain error
+
+        {
+            unsigned int is_x_snan;
+            UT32 xm; xm.f32 = f;
+            is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+            __amd_handle_errorf(DOMAIN, EDOM, "roundf", f, is_x_snan, 0.0F , 0,u32f.f32, 0);
+        }
+
+		
+		return u32f.f32;
+    }
+    /*Get the exponent of the input*/
+    intexp = (u32f.u32 & 0x7f800000) >> 23;
+    intexp -= 0x7F;
+    /*If exponent is greater than 22 then the number is already
+      rounded*/
+    if (intexp > 22)
+        return f;
+    if (intexp < 0)
+    {
+        u32Temp.f32 = f;
+        u32Temp.u32 &= 0x7FFFFFFF;
+        /*Add with a large number (2^23 +1) = 8388609.0F 
+        to force an overflow*/
+        u32Temp.f32 = (u32Temp.f32 + 8388609.0F);
+        /*Substract back with t he large number*/
+        u32Temp.f32 -= 8388609;
+        if (u32sign)
+            u32Temp.u32 |= 0x80000000;
+        return u32Temp.f32;
+    }
+    else
+    {
+        /*if(intexp == -1)
+            u32exp = 0x3F800000;       */
+        u32f.u32 &= 0x7FFFFFFF;
+        u32f.f32 += 0.5;
+        u32exp = u32f.u32 & 0x7F800000;
+        /*right shift then left shift to discard the decimal
+          places*/
+        u32mantissa = (u32f.u32 & MANTBITS_SP32) >> (23 - intexp);
+        u32mantissa = u32mantissa << (23 - intexp);
+        u32Temp.u32 = u32sign | u32exp | u32mantissa;
+        return (u32Temp.f32);
+    }
+}
+
diff --git a/src/scalbln.c b/src/scalbln.c
new file mode 100644
index 0000000..51499d8
--- /dev/null
+++ b/src/scalbln.c
@@ -0,0 +1,119 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifdef WIN64
+#include <fpieee.h>
+#else
+#include <errno.h>
+#endif
+
+#include <math.h>
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#include "../inc/libm_special.h"
+
+
+double FN_PROTOTYPE(scalbln)(double x, long int n)
+{
+    UT64 val;
+    unsigned int sign;
+    int exponent;
+    val.f64 = x;
+    sign = val.u32[1] & 0x80000000;
+    val.u32[1] = val.u32[1] & 0x7fffffff; /* remove the sign bit */
+
+    if((val.u32[1] & 0x7ff00000)== 0x7ff00000)/* x= nan or x = +-inf*/
+        return x+x;
+
+    if((val.u64 == 0x0000000000000000) || (n==0))
+        return x; /* x= +-0 or n= 0*/
+
+    exponent = val.u32[1] >> 20; /* get the exponent */
+
+    if(exponent == 0)/*x is denormal*/
+    {
+		val.f64 = val.f64 * VAL_2PMULTIPLIER_DP;/*multiply by 2^53 to bring it to the normal range*/
+        exponent = val.u32[1] >> 20; /* get the exponent */
+		exponent = exponent + n - MULTIPLIER_DP;
+		if(exponent < -MULTIPLIER_DP)/*underflow*/
+		{
+			val.u32[1] = sign | 0x00000000;
+			val.u32[0] = 0x00000000;
+
+			__amd_handle_error(UNDERFLOW, ERANGE, "scalbln", x, (double)n ,val.f64);
+			
+			return val.f64;
+		}
+		if(exponent > 2046)/*overflow*/
+		{
+			val.u32[1] = sign | 0x7ff00000;
+			val.u32[0] = 0x00000000;
+
+			__amd_handle_error(OVERFLOW, ERANGE, "scalbln", x, (double)n ,val.f64);
+			
+
+			return val.f64;
+		}
+
+		exponent += MULTIPLIER_DP;
+		val.u32[1] = sign | (exponent << 20) | (val.u32[1] & 0x000fffff);
+		val.f64 = val.f64 * VAL_2PMMULTIPLIER_DP;
+        return val.f64;
+    }
+
+    exponent += n;
+
+    if(exponent < -MULTIPLIER_DP)/*underflow*/
+	{
+		val.u32[1] = sign | 0x00000000;
+		val.u32[0] = 0x00000000;
+
+		__amd_handle_error(UNDERFLOW, ERANGE, "scalbln", x, (double)n ,val.f64);
+		
+		return val.f64;
+	}
+
+    if(exponent < 1)/*x is normal but output is debnormal*/
+    {
+		exponent += MULTIPLIER_DP;
+		val.u32[1] = sign | (exponent << 20) | (val.u32[1] & 0x000fffff);
+		val.f64 = val.f64 * VAL_2PMMULTIPLIER_DP;
+        return val.f64;
+    }
+
+    if(exponent > 2046)/*overflow*/
+	{
+		val.u32[1] = sign | 0x7ff00000;
+		val.u32[0] = 0x00000000;
+
+		__amd_handle_error(OVERFLOW, ERANGE, "scalbln", x, (double)n ,val.f64);
+		
+
+		return val.f64;
+	}
+
+    val.u32[1] = sign | (exponent << 20) | (val.u32[1] & 0x000fffff);
+    return val.f64;
+}
+
diff --git a/src/scalblnf.c b/src/scalblnf.c
new file mode 100644
index 0000000..cc627bb
--- /dev/null
+++ b/src/scalblnf.c
@@ -0,0 +1,133 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifdef WIN64
+#include <fpieee.h>
+#else
+#include <errno.h>
+#endif
+
+#include <math.h>
+#include "../inc/libm_amd.h"
+
+#include "../inc/libm_util_amd.h"
+
+#include "../inc/libm_special.h"
+
+float FN_PROTOTYPE(scalblnf)(float x, long int n)
+{
+    UT32 val;
+    unsigned int sign;
+    int exponent;
+    val.f32 = x;
+    sign = val.u32 & 0x80000000;
+    val.u32 = val.u32 & 0x7fffffff;/* remove the sign bit */
+
+    if((val.u32 & 0x7f800000)== 0x7f800000)/* x= nan or x = +-inf*/
+        return x+x;
+
+    if((val.u32 == 0x00000000) || (n==0))/* x= +-0 or n= 0*/
+        return x;
+
+    exponent = val.u32 >> 23; /* get the exponent */
+
+	if(exponent == 0)/*x is denormal*/
+	{
+		val.f32 = val.f32 * VAL_2PMULTIPLIER_SP;/*multiply by 2^24 to bring it to the normal range*/
+		exponent = (val.u32 >> 23); /* get the exponent */
+		exponent = exponent + n - MULTIPLIER_SP;
+		if(exponent < -MULTIPLIER_SP)/*underflow*/
+		{
+			val.u32 = sign | 0x00000000;
+
+            {
+                unsigned int is_x_snan;
+                UT32 xm; xm.f32 = x;
+                is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+                __amd_handle_errorf(UNDERFLOW, ERANGE, "scalblnf", x, is_x_snan, (float)n, 0,val.f32, 0);
+            }
+			
+			return val.f32;
+		}
+		if(exponent > 254)/*overflow*/
+		{
+			val.u32 = sign | 0x7f800000;
+
+            {
+                unsigned int is_x_snan;
+                UT32 xm; xm.f32 = x;
+                is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+                __amd_handle_errorf(OVERFLOW, ERANGE, "scalblnf", x, is_x_snan, (float)n, 0,val.f32, 0);
+            }
+    		
+			return val.f32;
+		}
+
+		exponent += MULTIPLIER_SP;
+		val.u32 = sign | (exponent << 23) | (val.u32 & 0x007fffff);
+		val.f32 = val.f32 * VAL_2PMMULTIPLIER_SP;
+        return val.f32;
+	}
+
+    exponent += n;
+
+    if(exponent < -MULTIPLIER_SP)/*underflow*/
+	{
+		val.u32 = sign | 0x00000000;
+
+        {
+            unsigned int is_x_snan;
+            UT32 xm; xm.f32 = x;
+            is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+            __amd_handle_errorf(UNDERFLOW, ERANGE, "scalblnf", x, is_x_snan, (float)n, 0,val.f32, 0);
+        }
+		
+		return val.f32;
+	}
+
+    if(exponent < 1)/*x is normal but output is debnormal*/
+    {
+		exponent += MULTIPLIER_SP;
+		val.u32 = sign | (exponent << 23) | (val.u32 & 0x007fffff);
+		val.f32 = val.f32 * VAL_2PMMULTIPLIER_SP;
+        return val.f32;
+    }
+
+    if(exponent > 254)/*overflow*/
+	{
+		val.u32 = sign | 0x7f800000;
+
+        {
+            unsigned int is_x_snan;
+            UT32 xm; xm.f32 = x;
+            is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+            __amd_handle_errorf(OVERFLOW, ERANGE, "scalblnf", x, is_x_snan, (float)n, 0,val.f32, 0);
+        }
+		
+		return val.f32;
+	}
+
+    val.u32 = sign | (exponent << 23) | (val.u32 & 0x007fffff);/*x is normal and output is normal*/
+    return val.f32;
+}
+
diff --git a/src/scalbn.c b/src/scalbn.c
new file mode 100644
index 0000000..facb718
--- /dev/null
+++ b/src/scalbn.c
@@ -0,0 +1,117 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifdef WIN64
+#include <fpieee.h>
+#else
+#include <errno.h>
+#endif
+
+#include <math.h>
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#include "../inc/libm_special.h"
+
+
+
+double FN_PROTOTYPE(scalbn)(double x, int n)
+{
+    UT64 val;
+    unsigned int sign;
+    int exponent;
+    val.f64 = x;
+    sign = val.u32[1] & 0x80000000;
+    val.u32[1] = val.u32[1] & 0x7fffffff; /* remove the sign bit */
+
+    if((val.u32[1] & 0x7ff00000)== 0x7ff00000)/* x= nan or x = +-inf*/
+        return x+x;
+
+    if((val.u64 == 0x0000000000000000) || (n==0))
+        return x; /* x= +-0 or n= 0*/
+
+    exponent = val.u32[1] >> 20; /* get the exponent */
+
+    if(exponent == 0)/*x is denormal*/
+    {
+		val.f64 = val.f64 * VAL_2PMULTIPLIER_DP;/*multiply by 2^53 to bring it to the normal range*/
+        exponent = val.u32[1] >> 20; /* get the exponent */
+		exponent = exponent + n - MULTIPLIER_DP;
+		if(exponent < -MULTIPLIER_DP)/*underflow*/
+		{
+			val.u32[1] = sign | 0x00000000;
+			val.u32[0] = 0x00000000;
+			__amd_handle_error(UNDERFLOW, ERANGE, "scalbn", x, (double) n , val.f64);
+			
+			return val.f64;
+		}
+		if(exponent > 2046)/*overflow*/
+		{
+			val.u32[1] = sign | 0x7ff00000;
+			val.u32[0] = 0x00000000;
+
+			__amd_handle_error(OVERFLOW, ERANGE, "scalbn", x, (double) n , val.f64);
+			
+			return val.f64;
+		}
+
+		exponent += MULTIPLIER_DP;
+		val.u32[1] = sign | (exponent << 20) | (val.u32[1] & 0x000fffff);
+		val.f64 = val.f64 * VAL_2PMMULTIPLIER_DP;
+        return val.f64;
+    }
+
+    exponent += n;
+
+    if(exponent < -MULTIPLIER_DP)/*underflow*/
+	{
+       val.u32[1] = sign | 0x00000000;
+       val.u32[0] = 0x00000000;
+
+		__amd_handle_error(UNDERFLOW, ERANGE, "scalbn", x, (double) n , val.f64);
+		
+       return val.f64;
+	}
+
+    if(exponent < 1)/*x is normal but output is debnormal*/
+    {
+		exponent += MULTIPLIER_DP;
+		val.u32[1] = sign | (exponent << 20) | (val.u32[1] & 0x000fffff);
+		val.f64 = val.f64 * VAL_2PMMULTIPLIER_DP;
+        return val.f64;
+    }
+
+    if(exponent > 2046)/*overflow*/
+	{
+		val.u32[1] = sign | 0x7ff00000;
+		val.u32[0] = 0x00000000;
+
+		__amd_handle_error(OVERFLOW, ERANGE, "scalbn", x, (double) n , val.f64);
+		
+		return val.f64;
+	}
+
+    val.u32[1] = sign | (exponent << 20) | (val.u32[1] & 0x000fffff);
+    return val.f64;
+}
+
diff --git a/src/scalbnf.c b/src/scalbnf.c
new file mode 100644
index 0000000..1477fe1
--- /dev/null
+++ b/src/scalbnf.c
@@ -0,0 +1,138 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#ifdef WIN64
+#include <fpieee.h>
+#else
+#include <errno.h>
+#endif
+
+#include <math.h>
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#include "../inc/libm_special.h"
+
+float FN_PROTOTYPE(scalbnf)(float x, int n)
+{
+    UT32 val;
+    unsigned int sign;
+    int exponent;
+    val.f32 = x;
+    sign = val.u32 & 0x80000000;
+    val.u32 = val.u32 & 0x7fffffff;/* remove the sign bit */
+
+    if((val.u32 & 0x7f800000)== 0x7f800000)/* x= nan or x = +-inf*/
+        return x+x;
+
+    if((val.u32 == 0x00000000) || (n==0))/* x= +-0 or n= 0*/
+        return x;
+
+    exponent = val.u32 >> 23; /* get the exponent */
+
+	if(exponent == 0)/*x is denormal*/
+	{
+		val.f32 = val.f32 * VAL_2PMULTIPLIER_SP;/*multiply by 2^24 to bring it to the normal range*/
+		exponent = (val.u32 >> 23); /* get the exponent */
+		exponent = exponent + n - MULTIPLIER_SP;
+		if(exponent < -MULTIPLIER_SP)/*underflow*/
+		{
+			val.u32 = sign | 0x00000000;
+
+            {
+                unsigned int is_x_snan;
+                UT32 xm; xm.f32 = x;
+                is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+                __amd_handle_errorf(UNDERFLOW, ERANGE, "scalbnf", x, is_x_snan, (float) n , 0, val.f32, 0);
+
+            }
+			
+			return val.f32;
+		}
+		if(exponent > 254)/*overflow*/
+		{
+			val.u32 = sign | 0x7f800000;
+
+            {
+                unsigned int is_x_snan;
+                UT32 xm; xm.f32 = x;
+                is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+                __amd_handle_errorf(OVERFLOW, ERANGE, "scalbnf", x, is_x_snan, (float) n , 0, val.f32, 0);
+
+            }
+
+			
+			return val.f32;
+		}
+
+		exponent += MULTIPLIER_SP;
+		val.u32 = sign | (exponent << 23) | (val.u32 & 0x007fffff);
+		val.f32 = val.f32 * VAL_2PMMULTIPLIER_SP;
+        return val.f32;
+	}
+
+    exponent += n;
+
+    if(exponent < -MULTIPLIER_SP)/*underflow*/
+	{
+		val.u32 = sign | 0x00000000;
+
+        {
+            unsigned int is_x_snan;
+            UT32 xm; xm.f32 = x;
+            is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+            __amd_handle_errorf(UNDERFLOW, ERANGE, "scalbnf", x, is_x_snan, (float) n , 0, val.f32, 0);
+
+        }
+
+		
+		return val.f32;
+	}
+
+    if(exponent < 1)/*x is normal but output is debnormal*/
+    {
+		exponent += MULTIPLIER_SP;
+		val.u32 = sign | (exponent << 23) | (val.u32 & 0x007fffff);
+		val.f32 = val.f32 * VAL_2PMMULTIPLIER_SP;
+        return val.f32;
+    }
+
+    if(exponent > 254)/*overflow*/
+	{
+		val.u32 = sign | 0x7f800000;
+
+        {
+            unsigned int is_x_snan;
+            UT32 xm; xm.f32 = x;
+            is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+            __amd_handle_errorf(OVERFLOW, ERANGE, "scalbnf", x, is_x_snan, (float) n , 0, val.f32, 0);
+
+        }
+
+	    return val.f32;
+	}
+
+    val.u32 = sign | (exponent << 23) | (val.u32 & 0x007fffff);/*x is normal and output is normal*/
+    return val.f32;
+}
+
diff --git a/src/sincos_special.c b/src/sincos_special.c
new file mode 100644
index 0000000..c349d10
--- /dev/null
+++ b/src/sincos_special.c
@@ -0,0 +1,151 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include <emmintrin.h>
+#include <math.h>
+#include <errno.h>
+
+
+#include "../inc/libm_util_amd.h"
+#include "../inc/libm_special.h"
+
+double _sin_cos_special(double x, const char *name)
+{
+    UT64 xu;
+	unsigned int is_snan;
+
+	xu.f64 = x;
+
+    if((xu.u64 & EXPBITS_DP64) == EXPBITS_DP64)
+    {
+        // x is Inf or NaN
+        if((xu.u64 & MANTBITS_DP64) == 0x0)
+        {
+            // x is Inf
+            _mm_setcsr(_mm_getcsr() | MXCSR_ES_INVALID); 
+#ifdef WIN64
+            xu.u64 = INDEFBITPATT_DP64;
+			__amd_handle_error(DOMAIN, EDOM, name, x, 0, xu.f64);
+#else
+			xu.u64 = QNANBITPATT_DP64;
+            name = *(&name); // dummy statement to avoid warning
+#endif
+		}
+		else {
+			// x is NaN
+            is_snan = (((xu.u64 & QNAN_MASK_64) == QNAN_MASK_64) ? 0 : 1);
+			if(is_snan){
+				xu.u64 |= QNAN_MASK_64;
+#ifdef WIN64
+#else
+				_mm_setcsr(_mm_getcsr() | MXCSR_ES_INVALID);
+#endif
+			}
+#ifdef WIN64
+			__amd_handle_error(DOMAIN, EDOM, name, x, 0, xu.f64);
+#endif
+		}
+		
+	}
+
+	return xu.f64;
+}
+
+float _sinf_cosf_special(float x, const char *name)
+{
+    UT32 xu;
+	unsigned int is_snan;
+
+	xu.f32 = x;
+
+    if((xu.u32 & EXPBITS_SP32) == EXPBITS_SP32)
+    {
+        // x is Inf or NaN
+        if((xu.u32 & MANTBITS_SP32) == 0x0)
+        {
+            // x is Inf	
+            _mm_setcsr(_mm_getcsr() | MXCSR_ES_INVALID);
+#ifdef WIN64
+            xu.u32 = INDEFBITPATT_SP32;
+			__amd_handle_errorf(DOMAIN, EDOM, name, x, 0, 0.0f, 0, xu.f32, 0);
+#else
+			xu.u32 = QNANBITPATT_SP32; 
+            name = *(&name); // dummy statement to avoid warning
+#endif
+		}
+		else {
+			// x is NaN
+            is_snan = (((xu.u32 & QNAN_MASK_32) == QNAN_MASK_32) ? 0 : 1);
+			if(is_snan) {
+				xu.u32 |= QNAN_MASK_32;
+				_mm_setcsr(_mm_getcsr() | MXCSR_ES_INVALID);
+			}
+#ifdef WIN64
+			__amd_handle_errorf(DOMAIN, EDOM, name, x, is_snan, 0.0f, 0, xu.f32, 0);
+#endif
+		}
+		
+	}
+
+	return xu.f32;
+}
+
+float _sinf_special(float x)
+{
+	return _sinf_cosf_special(x, "sinf");
+}
+
+double _sin_special(double x)
+{
+	return _sin_cos_special(x, "sin");
+}
+
+float _cosf_special(float x)
+{
+	return _sinf_cosf_special(x, "cosf");
+}
+
+double _cos_special(double x)
+{
+	return _sin_cos_special(x, "cos");
+}
+
+void _sincosf_special(float x, float *sy, float *cy)
+{
+    float xu = _sinf_cosf_special(x, "sincosf");
+
+	*sy = xu;
+	*cy = xu;
+
+	return;
+}
+
+void _sincos_special(double x, double *sy, double *cy)
+{
+    double xu = _sin_cos_special(x, "sincos");
+
+	*sy = xu;
+	*cy = xu;
+
+	return;
+}
diff --git a/src/sinh.c b/src/sinh.c
new file mode 100644
index 0000000..f22fee4
--- /dev/null
+++ b/src/sinh.c
@@ -0,0 +1,371 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#define USE_SPLITEXP
+#define USE_SCALEDOUBLE_1
+#define USE_SCALEDOUBLE_2
+#define USE_INFINITY_WITH_FLAGS
+#define USE_VAL_WITH_FLAGS
+#define USE_HANDLE_ERROR
+#include "../inc/libm_inlines_amd.h"
+#undef USE_HANDLE_ERROR
+#undef USE_SPLITEXP
+#undef USE_SCALEDOUBLE_1
+#undef USE_SCALEDOUBLE_2
+#undef USE_INFINITY_WITH_FLAGS
+#undef USE_VAL_WITH_FLAGS
+
+#include "../inc/libm_errno_amd.h"
+
+#ifndef WINDOWS
+
+/* Deal with errno for out-of-range result */
+static inline double retval_errno_erange(double x, int xneg)
+{
+  struct exception exc;
+  exc.arg1 = x;
+  exc.arg2 = x;
+  exc.type = OVERFLOW;
+  exc.name = (char *)"sinh";
+  if (_LIB_VERSION == _SVID_)
+    {
+      if (xneg)
+        exc.retval = -HUGE;
+      else
+        exc.retval = HUGE;
+    }
+  else
+    {
+      if (xneg)
+        exc.retval = -infinity_with_flags(AMD_F_OVERFLOW);
+      else
+        exc.retval = infinity_with_flags(AMD_F_OVERFLOW);
+    }
+  if (_LIB_VERSION == _POSIX_)
+    __set_errno(ERANGE);
+  else if (!matherr(&exc))
+    __set_errno(ERANGE);
+  return exc.retval;
+}
+#endif
+
+double FN_PROTOTYPE(sinh)(double x)
+{
+  /*
+    After dealing with special cases the computation is split into
+    regions as follows:
+
+    abs(x) >= max_sinh_arg:
+    sinh(x) = sign(x)*Inf
+
+    abs(x) >= small_threshold:
+    sinh(x) = sign(x)*exp(abs(x))/2 computed using the
+    splitexp and scaleDouble functions as for exp_amd().
+
+    abs(x) < small_threshold:
+    compute p = exp(y) - 1 and then z = 0.5*(p+(p/(p+1.0)))
+    sinh(x) is then sign(x)*z.                             */
+
+  static const double
+    max_sinh_arg = 7.10475860073943977113e+02, /* 0x408633ce8fb9f87e */
+    thirtytwo_by_log2 = 4.61662413084468283841e+01, /* 0x40471547652b82fe */
+    log2_by_32_lead = 2.16608493356034159660e-02, /* 0x3f962e42fe000000 */
+    log2_by_32_tail = 5.68948749532545630390e-11, /* 0x3dcf473de6af278e */
+    small_threshold = 8*BASEDIGITS_DP64*0.30102999566398119521373889;
+  /* (8*BASEDIGITS_DP64*log10of2) ' exp(-x) insignificant c.f. exp(x) */
+
+  /* Lead and tail tabulated values of sinh(i) and cosh(i)
+     for i = 0,...,36. The lead part has 26 leading bits. */
+
+  static const double sinh_lead[37] = {
+    0.00000000000000000000e+00,  /* 0x0000000000000000 */
+    1.17520117759704589844e+00,  /* 0x3ff2cd9fc0000000 */
+    3.62686038017272949219e+00,  /* 0x400d03cf60000000 */
+    1.00178747177124023438e+01,  /* 0x40240926e0000000 */
+    2.72899169921875000000e+01,  /* 0x403b4a3800000000 */
+    7.42032089233398437500e+01,  /* 0x40528d0160000000 */
+    2.01713153839111328125e+02,  /* 0x406936d228000000 */
+    5.48316116333007812500e+02,  /* 0x4081228768000000 */
+    1.49047882080078125000e+03,  /* 0x409749ea50000000 */
+    4.05154187011718750000e+03,  /* 0x40afa71570000000 */
+    1.10132326660156250000e+04,  /* 0x40c5829dc8000000 */
+    2.99370708007812500000e+04,  /* 0x40dd3c4488000000 */
+    8.13773945312500000000e+04,  /* 0x40f3de1650000000 */
+    2.21206695312500000000e+05,  /* 0x410b00b590000000 */
+    6.01302140625000000000e+05,  /* 0x412259ac48000000 */
+    1.63450865625000000000e+06,  /* 0x4138f0cca8000000 */
+    4.44305525000000000000e+06,  /* 0x4150f2ebd0000000 */
+    1.20774762500000000000e+07,  /* 0x4167093488000000 */
+    3.28299845000000000000e+07,  /* 0x417f4f2208000000 */
+    8.92411500000000000000e+07,  /* 0x419546d8f8000000 */
+    2.42582596000000000000e+08,  /* 0x41aceb0888000000 */
+    6.59407856000000000000e+08,  /* 0x41c3a6e1f8000000 */
+    1.79245641600000000000e+09,  /* 0x41dab5adb8000000 */
+    4.87240166400000000000e+09,  /* 0x41f226af30000000 */
+    1.32445608960000000000e+10,  /* 0x4208ab7fb0000000 */
+    3.60024494080000000000e+10,  /* 0x4220c3d390000000 */
+    9.78648043520000000000e+10,  /* 0x4236c93268000000 */
+    2.66024116224000000000e+11,  /* 0x424ef822f0000000 */
+    7.23128516608000000000e+11,  /* 0x42650bba30000000 */
+    1.96566712320000000000e+12,  /* 0x427c9aae40000000 */
+    5.34323724288000000000e+12,  /* 0x4293704708000000 */
+    1.45244246507520000000e+13,  /* 0x42aa6b7658000000 */
+    3.94814795284480000000e+13,  /* 0x42c1f43fc8000000 */
+    1.07321789251584000000e+14,  /* 0x42d866f348000000 */
+    2.91730863685632000000e+14,  /* 0x42f0953e28000000 */
+    7.93006722514944000000e+14,  /* 0x430689e220000000 */
+    2.15561576592179200000e+15}; /* 0x431ea215a0000000 */
+
+  static const double sinh_tail[37] = {
+    0.00000000000000000000e+00,  /* 0x0000000000000000 */
+    1.60467555584448807892e-08,  /* 0x3e513ae6096a0092 */
+    2.76742892754807136947e-08,  /* 0x3e5db70cfb79a640 */
+    2.09697499555224576530e-07,  /* 0x3e8c2526b66dc067 */
+    2.04940252448908240062e-07,  /* 0x3e8b81b18647f380 */
+    1.65444891522700935932e-06,  /* 0x3ebbc1cdd1e1eb08 */
+    3.53116789999998198721e-06,  /* 0x3ecd9f201534fb09 */
+    6.94023870987375490695e-06,  /* 0x3edd1c064a4e9954 */
+    4.98876893611587449271e-06,  /* 0x3ed4eca65d06ea74 */
+    3.19656024605152215752e-05,  /* 0x3f00c259bcc0ecc5 */
+    2.08687768377236501204e-04,  /* 0x3f2b5a6647cf9016 */
+    4.84668088325403796299e-05,  /* 0x3f09691adefb0870 */
+    1.17517985422733832468e-03,  /* 0x3f53410fc29cde38 */
+    6.90830086959560562415e-04,  /* 0x3f46a31a50b6fb3c */
+    1.45697262451506548420e-03,  /* 0x3f57defc71805c40 */
+    2.99859023684906737806e-02,  /* 0x3f9eb49fd80e0bab */
+    1.02538800507941396667e-02,  /* 0x3f84fffc7bcd5920 */
+    1.26787628407699110022e-01,  /* 0x3fc03a93b6c63435 */
+    6.86652479544033744752e-02,  /* 0x3fb1940bb255fd1c */
+    4.81593627621056619148e-01,  /* 0x3fded26e14260b50 */
+    1.70489513795397629181e+00,  /* 0x3ffb47401fc9f2a2 */
+    1.12416073482258713767e+01,  /* 0x40267bb3f55634f1 */
+    7.06579578070110514432e+00,  /* 0x401c435ff8194ddc */
+    5.91244512999659974639e+01,  /* 0x404d8fee052ba63a */
+    1.68921736147050694399e+02,  /* 0x40651d7edccde3f6 */
+    2.60692936262073658327e+02,  /* 0x40704b1644557d1a */
+    3.62419382134885609048e+02,  /* 0x4076a6b5ca0a9dc4 */
+    4.07689930834187271103e+03,  /* 0x40afd9cc72249aba */
+    1.55377375868385224749e+04,  /* 0x40ce58de693edab5 */
+    2.53720210371943067003e+04,  /* 0x40d8c70158ac6363 */
+    4.78822310734952334315e+04,  /* 0x40e7614764f43e20 */
+    1.81871712615542812273e+05,  /* 0x4106337db36fc718 */
+    5.62892347580489004031e+05,  /* 0x41212d98b1f611e2 */
+    6.41374032312148716301e+05,  /* 0x412392bc108b37cc */
+    7.57809544070145115256e+06,  /* 0x415ce87bdc3473dc */
+    3.64177136406482197344e+06,  /* 0x414bc8d5ae99ad14 */
+    7.63580561355670914054e+06}; /* 0x415d20d76744835c */
+
+  static const double cosh_lead[37] = {
+    1.00000000000000000000e+00,  /* 0x3ff0000000000000 */
+    1.54308062791824340820e+00,  /* 0x3ff8b07550000000 */
+    3.76219564676284790039e+00,  /* 0x400e18fa08000000 */
+    1.00676617622375488281e+01,  /* 0x402422a490000000 */
+    2.73082327842712402344e+01,  /* 0x403b4ee858000000 */
+    7.42099475860595703125e+01,  /* 0x40528d6fc8000000 */
+    2.01715633392333984375e+02,  /* 0x406936e678000000 */
+    5.48317031860351562500e+02,  /* 0x4081228948000000 */
+    1.49047915649414062500e+03,  /* 0x409749eaa8000000 */
+    4.05154199218750000000e+03,  /* 0x40afa71580000000 */
+    1.10132329101562500000e+04,  /* 0x40c5829dd0000000 */
+    2.99370708007812500000e+04,  /* 0x40dd3c4488000000 */
+    8.13773945312500000000e+04,  /* 0x40f3de1650000000 */
+    2.21206695312500000000e+05,  /* 0x410b00b590000000 */
+    6.01302140625000000000e+05,  /* 0x412259ac48000000 */
+    1.63450865625000000000e+06,  /* 0x4138f0cca8000000 */
+    4.44305525000000000000e+06,  /* 0x4150f2ebd0000000 */
+    1.20774762500000000000e+07,  /* 0x4167093488000000 */
+    3.28299845000000000000e+07,  /* 0x417f4f2208000000 */
+    8.92411500000000000000e+07,  /* 0x419546d8f8000000 */
+    2.42582596000000000000e+08,  /* 0x41aceb0888000000 */
+    6.59407856000000000000e+08,  /* 0x41c3a6e1f8000000 */
+    1.79245641600000000000e+09,  /* 0x41dab5adb8000000 */
+    4.87240166400000000000e+09,  /* 0x41f226af30000000 */
+    1.32445608960000000000e+10,  /* 0x4208ab7fb0000000 */
+    3.60024494080000000000e+10,  /* 0x4220c3d390000000 */
+    9.78648043520000000000e+10,  /* 0x4236c93268000000 */
+    2.66024116224000000000e+11,  /* 0x424ef822f0000000 */
+    7.23128516608000000000e+11,  /* 0x42650bba30000000 */
+    1.96566712320000000000e+12,  /* 0x427c9aae40000000 */
+    5.34323724288000000000e+12,  /* 0x4293704708000000 */
+    1.45244246507520000000e+13,  /* 0x42aa6b7658000000 */
+    3.94814795284480000000e+13,  /* 0x42c1f43fc8000000 */
+    1.07321789251584000000e+14,  /* 0x42d866f348000000 */
+    2.91730863685632000000e+14,  /* 0x42f0953e28000000 */
+    7.93006722514944000000e+14,  /* 0x430689e220000000 */
+    2.15561576592179200000e+15}; /* 0x431ea215a0000000 */
+
+  static const double cosh_tail[37] = {
+    0.00000000000000000000e+00,  /* 0x0000000000000000 */
+    6.89700037027478056904e-09,  /* 0x3e3d9f5504c2bd28 */
+    4.43207835591715833630e-08,  /* 0x3e67cb66f0a4c9fd */
+    2.33540217013828929694e-07,  /* 0x3e8f58617928e588 */
+    5.17452463948269748331e-08,  /* 0x3e6bc7d000c38d48 */
+    9.38728274131605919153e-07,  /* 0x3eaf7f9d4e329998 */
+    2.73012191010840495544e-06,  /* 0x3ec6e6e464885269 */
+    3.29486051438996307950e-06,  /* 0x3ecba3a8b946c154 */
+    4.75803746362771416375e-06,  /* 0x3ed3f4e76110d5a4 */
+    3.33050940471947692369e-05,  /* 0x3f017622515a3e2b */
+    9.94707313972136215365e-06,  /* 0x3ee4dc4b528af3d0 */
+    6.51685096227860253398e-05,  /* 0x3f11156278615e10 */
+    1.18132406658066663359e-03,  /* 0x3f535ad50ed821f5 */
+    6.93090416366541877541e-04,  /* 0x3f46b61055f2935c */
+    1.45780415323416845386e-03,  /* 0x3f57e2794a601240 */
+    2.99862082708111758744e-02,  /* 0x3f9eb4b45f6aadd3 */
+    1.02539925859688602072e-02,  /* 0x3f85000b967b3698 */
+    1.26787669807076286421e-01,  /* 0x3fc03a940fadc092 */
+    6.86652631843830962843e-02,  /* 0x3fb1940bf3bf874c */
+    4.81593633223853068159e-01,  /* 0x3fded26e1a2a2110 */
+    1.70489514001513020602e+00,  /* 0x3ffb4740205796d6 */
+    1.12416073489841270572e+01,  /* 0x40267bb3f55cb85d */
+    7.06579578098005001152e+00,  /* 0x401c435ff81e18ac */
+    5.91244513000686140458e+01,  /* 0x404d8fee052bdea4 */
+    1.68921736147088438429e+02,  /* 0x40651d7edccde926 */
+    2.60692936262087528121e+02,  /* 0x40704b1644557e0e */
+    3.62419382134890611269e+02,  /* 0x4076a6b5ca0a9e1c */
+    4.07689930834187453002e+03,  /* 0x40afd9cc72249abe */
+    1.55377375868385224749e+04,  /* 0x40ce58de693edab5 */
+    2.53720210371943103382e+04,  /* 0x40d8c70158ac6364 */
+    4.78822310734952334315e+04,  /* 0x40e7614764f43e20 */
+    1.81871712615542812273e+05,  /* 0x4106337db36fc718 */
+    5.62892347580489004031e+05,  /* 0x41212d98b1f611e2 */
+    6.41374032312148716301e+05,  /* 0x412392bc108b37cc */
+    7.57809544070145115256e+06,  /* 0x415ce87bdc3473dc */
+    3.64177136406482197344e+06,  /* 0x414bc8d5ae99ad14 */
+    7.63580561355670914054e+06}; /* 0x415d20d76744835c */
+
+  unsigned long long ux, aux, xneg;
+  double y, z, z1, z2;
+  int m;
+
+  /* Special cases */
+
+  GET_BITS_DP64(x, ux);
+  aux = ux & ~SIGNBIT_DP64;
+  if (aux < 0x3e30000000000000) /* |x| small enough that sinh(x) = x */
+    {
+      if (aux == 0)
+        /* with no inexact */
+        return x;
+      else
+        return val_with_flags(x, AMD_F_INEXACT);
+    }
+  else if (aux >= 0x7ff0000000000000) /* |x| is NaN or Inf */
+    {
+      return x + x;
+    }
+
+
+  xneg = (aux != ux);
+
+  y = x;
+  if (xneg) y = -x;
+
+  if (y >= max_sinh_arg)
+    {
+      /* Return +/-infinity with overflow flag */
+
+#ifdef WINDOWS
+      if (xneg)
+         return handle_error("sinh", NINFBITPATT_DP64, _OVERFLOW,
+                              AMD_F_OVERFLOW, EDOM, x, 0.0F);
+      else
+         return handle_error("sinh", PINFBITPATT_DP64, _OVERFLOW,
+                              AMD_F_OVERFLOW, ERANGE, x, 0.0F);
+#else
+      return retval_errno_erange(x, xneg);
+#endif
+    }
+  else if (y >= small_threshold)
+    {
+      /* In this range y is large enough so that
+         the negative exponential is negligible,
+         so sinh(y) is approximated by sign(x)*exp(y)/2. The
+         code below is an inlined version of that from
+         exp() with two changes (it operates on
+         y instead of x, and the division by 2 is
+         done by reducing m by 1). */
+
+      splitexp(y, 1.0, thirtytwo_by_log2, log2_by_32_lead,
+               log2_by_32_tail, &m, &z1, &z2);
+      m -= 1;
+
+      if (m >= EMIN_DP64 && m <= EMAX_DP64)
+        z = scaleDouble_1((z1+z2),m);
+      else
+        z = scaleDouble_2((z1+z2),m);
+    }
+  else
+    {
+      /* In this range we find the integer part y0 of y
+         and the increment dy = y - y0. We then compute
+
+         z = sinh(y) = sinh(y0)cosh(dy) + cosh(y0)sinh(dy)
+
+         where sinh(y0) and cosh(y0) are tabulated above. */
+
+      int ind;
+      double dy, dy2, sdy, cdy, sdy1, sdy2;
+
+      ind = (int)y;
+      dy = y - ind;
+
+      dy2 = dy*dy;
+      sdy = dy*dy2*(0.166666666666666667013899e0 +
+                    (0.833333333333329931873097e-2 +
+                     (0.198412698413242405162014e-3 +
+                      (0.275573191913636406057211e-5 +
+                       (0.250521176994133472333666e-7 +
+                        (0.160576793121939886190847e-9 +
+                         0.7746188980094184251527126e-12*dy2)*dy2)*dy2)*dy2)*dy2)*dy2);
+
+      cdy = dy2*(0.500000000000000005911074e0 +
+                 (0.416666666666660876512776e-1 +
+                  (0.138888888889814854814536e-2 +
+                   (0.248015872460622433115785e-4 +
+                    (0.275573350756016588011357e-6 +
+                     (0.208744349831471353536305e-8 +
+                      0.1163921388172173692062032e-10*dy2)*dy2)*dy2)*dy2)*dy2)*dy2);
+
+      /* At this point sinh(dy) is approximated by dy + sdy.
+	 Shift some significant bits from dy to sdy. */
+
+      GET_BITS_DP64(dy, ux);
+      ux &= 0xfffffffff8000000;
+      PUT_BITS_DP64(ux, sdy1);
+      sdy2 = sdy + (dy - sdy1);
+
+      z = ((((((cosh_tail[ind]*sdy2 + sinh_tail[ind]*cdy)
+	       + cosh_tail[ind]*sdy1) + sinh_tail[ind])
+	     + cosh_lead[ind]*sdy2) + sinh_lead[ind]*cdy)
+	   + cosh_lead[ind]*sdy1) + sinh_lead[ind];
+    }
+
+  if (xneg) z = - z;
+  return z;
+}
+
+weak_alias (__sinh, sinh)
diff --git a/src/sinhf.c b/src/sinhf.c
new file mode 100644
index 0000000..eaad0fd
--- /dev/null
+++ b/src/sinhf.c
@@ -0,0 +1,292 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#define USE_SPLITEXP
+#define USE_SCALEDOUBLE_1
+#define USE_INFINITY_WITH_FLAGS
+#define USE_VALF_WITH_FLAGS
+#define USE_HANDLE_ERRORF
+#include "../inc/libm_inlines_amd.h"
+#undef USE_SPLITEXP
+#undef USE_SCALEDOUBLE_1
+#undef USE_INFINITY_WITH_FLAGS
+#undef USE_VALF_WITH_FLAGS
+#undef USE_HANDLE_ERRORF
+
+#include "../inc/libm_errno_amd.h"
+
+#ifndef WINDOWS
+/* Deal with errno for out-of-range result */
+static inline float retval_errno_erange(float x, int xneg)
+{
+  struct exception exc;
+  exc.arg1 = (double)x;
+  exc.arg2 = (double)x;
+  exc.type = OVERFLOW;
+  exc.name = (char *)"sinhf";
+  if (_LIB_VERSION == _SVID_)
+    {
+      if (xneg)
+        exc.retval = -HUGE;
+      else
+        exc.retval = HUGE;
+    }
+  else
+    {
+      if (xneg)
+        exc.retval = -infinity_with_flags(AMD_F_OVERFLOW);
+      else
+        exc.retval = infinity_with_flags(AMD_F_OVERFLOW);
+    }
+  if (_LIB_VERSION == _POSIX_)
+    __set_errno(ERANGE);
+  else if (!matherr(&exc))
+    __set_errno(ERANGE);
+  return exc.retval;
+}
+#endif
+
+#ifdef WINDOWS
+#pragma function(sinhf)
+#endif
+
+float FN_PROTOTYPE(sinhf)(float fx)
+{
+  /*
+    After dealing with special cases the computation is split into
+    regions as follows:
+
+    abs(x) >= max_sinh_arg:
+    sinh(x) = sign(x)*Inf
+
+    abs(x) >= small_threshold:
+    sinh(x) = sign(x)*exp(abs(x))/2 computed using the
+    splitexp and scaleDouble functions as for exp_amd().
+
+    abs(x) < small_threshold:
+    compute p = exp(y) - 1 and then z = 0.5*(p+(p/(p+1.0)))
+    sinh(x) is then sign(x)*z.                             */
+
+  static const double
+    /* The max argument of sinhf, but stored as a double */
+    max_sinh_arg = 8.94159862922329438106e+01, /* 0x40565a9f84f82e63 */
+    thirtytwo_by_log2 = 4.61662413084468283841e+01, /* 0x40471547652b82fe */
+    log2_by_32_lead = 2.16608493356034159660e-02, /* 0x3f962e42fe000000 */
+    log2_by_32_tail = 5.68948749532545630390e-11, /* 0x3dcf473de6af278e */
+    small_threshold = 8*BASEDIGITS_DP64*0.30102999566398119521373889;
+  /* (8*BASEDIGITS_DP64*log10of2) ' exp(-x) insignificant c.f. exp(x) */
+
+  /* Tabulated values of sinh(i) and cosh(i) for i = 0,...,36. */
+
+  static const double sinh_lead[37] = {
+    0.00000000000000000000e+00,  /* 0x0000000000000000 */
+    1.17520119364380137839e+00,  /* 0x3ff2cd9fc44eb982 */
+    3.62686040784701857476e+00,  /* 0x400d03cf63b6e19f */
+    1.00178749274099008204e+01,  /* 0x40240926e70949ad */
+    2.72899171971277496596e+01,  /* 0x403b4a3803703630 */
+    7.42032105777887522891e+01,  /* 0x40528d0166f07374 */
+    2.01713157370279219549e+02,  /* 0x406936d22f67c805 */
+    5.48316123273246489589e+02,  /* 0x408122876ba380c9 */
+    1.49047882578955000099e+03,  /* 0x409749ea514eca65 */
+    4.05154190208278987484e+03,  /* 0x40afa7157430966f */
+    1.10132328747033916443e+04,  /* 0x40c5829dced69991 */
+    2.99370708492480553105e+04,  /* 0x40dd3c4488cb48d6 */
+    8.13773957064298447222e+04,  /* 0x40f3de1654d043f0 */
+    2.21206696003330085659e+05,  /* 0x410b00b5916a31a5 */
+    6.01302142081972560845e+05,  /* 0x412259ac48bef7e3 */
+    1.63450868623590236530e+06,  /* 0x4138f0ccafad27f6 */
+    4.44305526025387924165e+06,  /* 0x4150f2ebd0a7ffe3 */
+    1.20774763767876271158e+07,  /* 0x416709348c0ea4ed */
+    3.28299845686652474105e+07,  /* 0x417f4f22091940bb */
+    8.92411504815936237574e+07,  /* 0x419546d8f9ed26e1 */
+    2.42582597704895108938e+08,  /* 0x41aceb088b68e803 */
+    6.59407867241607308388e+08,  /* 0x41c3a6e1fd9eecfd */
+    1.79245642306579566002e+09,  /* 0x41dab5adb9c435ff */
+    4.87240172312445068359e+09,  /* 0x41f226af33b1fdc0 */
+    1.32445610649217357635e+10,  /* 0x4208ab7fb5475fb7 */
+    3.60024496686929321289e+10,  /* 0x4220c3d3920962c8 */
+    9.78648047144193725586e+10,  /* 0x4236c932696a6b5c */
+    2.66024120300899291992e+11,  /* 0x424ef822f7f6731c */
+    7.23128532145737548828e+11,  /* 0x42650bba3796379a */
+    1.96566714857202099609e+12,  /* 0x427c9aae4631c056 */
+    5.34323729076223046875e+12,  /* 0x429370470aec28ec */
+    1.45244248326237109375e+13,  /* 0x42aa6b765d8cdf6c */
+    3.94814800913403437500e+13,  /* 0x42c1f43fcc4b662c */
+    1.07321789892958031250e+14,  /* 0x42d866f34a725782 */
+    2.91730871263727437500e+14,  /* 0x42f0953e2f3a1ef7 */
+    7.93006726156715250000e+14,  /* 0x430689e221bc8d5a */
+    2.15561577355759750000e+15}; /* 0x431ea215a1d20d76 */
+
+  static const double cosh_lead[37] = {
+    1.00000000000000000000e+00,  /* 0x3ff0000000000000 */
+    1.54308063481524371241e+00,  /* 0x3ff8b07551d9f550 */
+    3.76219569108363138810e+00,  /* 0x400e18fa0df2d9bc */
+    1.00676619957777653269e+01,  /* 0x402422a497d6185e */
+    2.73082328360164865444e+01,  /* 0x403b4ee858de3e80 */
+    7.42099485247878334349e+01,  /* 0x40528d6fcbeff3a9 */
+    2.01715636122455890700e+02,  /* 0x406936e67db9b919 */
+    5.48317035155212010977e+02,  /* 0x4081228949ba3a8b */
+    1.49047916125217807348e+03,  /* 0x409749eaa93f4e76 */
+    4.05154202549259389343e+03,  /* 0x40afa715845d8894 */
+    1.10132329201033226127e+04,  /* 0x40c5829dd053712d */
+    2.99370708659497577173e+04,  /* 0x40dd3c4489115627 */
+    8.13773957125740562333e+04,  /* 0x40f3de1654d6b543 */
+    2.21206696005590405548e+05,  /* 0x410b00b5916b6105 */
+    6.01302142082804115489e+05,  /* 0x412259ac48bf13ca */
+    1.63450868623620807193e+06,  /* 0x4138f0ccafad2d17 */
+    4.44305526025399193168e+06,  /* 0x4150f2ebd0a8005c */
+    1.20774763767876680940e+07,  /* 0x416709348c0ea503 */
+    3.28299845686652623117e+07,  /* 0x417f4f22091940bf */
+    8.92411504815936237574e+07,  /* 0x419546d8f9ed26e1 */
+    2.42582597704895138741e+08,  /* 0x41aceb088b68e804 */
+    6.59407867241607308388e+08,  /* 0x41c3a6e1fd9eecfd */
+    1.79245642306579566002e+09,  /* 0x41dab5adb9c435ff */
+    4.87240172312445068359e+09,  /* 0x41f226af33b1fdc0 */
+    1.32445610649217357635e+10,  /* 0x4208ab7fb5475fb7 */
+    3.60024496686929321289e+10,  /* 0x4220c3d3920962c8 */
+    9.78648047144193725586e+10,  /* 0x4236c932696a6b5c */
+    2.66024120300899291992e+11,  /* 0x424ef822f7f6731c */
+    7.23128532145737548828e+11,  /* 0x42650bba3796379a */
+    1.96566714857202099609e+12,  /* 0x427c9aae4631c056 */
+    5.34323729076223046875e+12,  /* 0x429370470aec28ec */
+    1.45244248326237109375e+13,  /* 0x42aa6b765d8cdf6c */
+    3.94814800913403437500e+13,  /* 0x42c1f43fcc4b662c */
+    1.07321789892958031250e+14,  /* 0x42d866f34a725782 */
+    2.91730871263727437500e+14,  /* 0x42f0953e2f3a1ef7 */
+    7.93006726156715250000e+14,  /* 0x430689e221bc8d5a */
+    2.15561577355759750000e+15}; /* 0x431ea215a1d20d76 */
+
+  unsigned long long ux, aux, xneg;
+  double x = fx, y, z, z1, z2;
+  int m;
+
+  /* Special cases */
+
+  GET_BITS_DP64(x, ux);
+  aux = ux & ~SIGNBIT_DP64;
+  if (aux < 0x3f10000000000000) /* |x| small enough that sinh(x) = x */
+    {
+      if (aux == 0)
+        /* with no inexact */
+        return fx;
+      else
+        return valf_with_flags(fx, AMD_F_INEXACT);
+    }
+  else if (aux >= 0x7ff0000000000000) /* |x| is NaN or Inf */
+    {
+#ifdef WINDOWS
+      if (aux > 0x7ff0000000000000)
+        {
+          /* x is NaN */
+          unsigned int uhx;
+          GET_BITS_SP32(fx, uhx);
+          return handle_errorf("sinhf", uhx|0x00400000, _DOMAIN,
+                               AMD_F_INVALID, EDOM, fx, 0.0F);
+        }
+      else
+#endif
+      return fx + fx;
+    }
+
+  xneg = (aux != ux);
+
+  y = x;
+  if (xneg) y = -x;
+
+  if (y >= max_sinh_arg)
+    {
+      /* Return infinity with overflow flag. */
+#ifdef WINDOWS
+      if (xneg)
+         return handle_errorf("sinhf", NINFBITPATT_SP32, _OVERFLOW,
+                              AMD_F_OVERFLOW, ERANGE, fx, 0.0F);
+      else
+         return handle_errorf("sinhf", PINFBITPATT_SP32, _OVERFLOW,
+                              AMD_F_OVERFLOW, ERANGE, fx, 0.0F);
+#else
+      /* This handles POSIX behaviour */
+      __set_errno(ERANGE);
+        z = infinity_with_flags(AMD_F_OVERFLOW);
+#endif
+    }
+  else if (y >= small_threshold)
+    {
+      /* In this range y is large enough so that
+         the negative exponential is negligible,
+         so sinh(y) is approximated by sign(x)*exp(y)/2. The
+         code below is an inlined version of that from
+         exp() with two changes (it operates on
+         y instead of x, and the division by 2 is
+         done by reducing m by 1). */
+
+      splitexp(y, 1.0, thirtytwo_by_log2, log2_by_32_lead,
+               log2_by_32_tail, &m, &z1, &z2);
+      m -= 1;
+      /* scaleDouble_1 is always safe because the argument x was
+         float, rather than double */
+      z = scaleDouble_1((z1+z2),m);
+    }
+  else
+    {
+      /* In this range we find the integer part y0 of y
+         and the increment dy = y - y0. We then compute
+
+         z = sinh(y) = sinh(y0)cosh(dy) + cosh(y0)sinh(dy)
+
+         where sinh(y0) and cosh(y0) are tabulated above. */
+
+      int ind;
+      double dy, dy2, sdy, cdy;
+
+      ind = (int)y;
+      dy = y - ind;
+
+      dy2 = dy*dy;
+
+      sdy = dy + dy*dy2*(0.166666666666666667013899e0 +
+			 (0.833333333333329931873097e-2 +
+			  (0.198412698413242405162014e-3 +
+			   (0.275573191913636406057211e-5 +
+			    (0.250521176994133472333666e-7 +
+			     (0.160576793121939886190847e-9 +
+			      0.7746188980094184251527126e-12*dy2)*dy2)*dy2)*dy2)*dy2)*dy2);
+
+      cdy = 1 + dy2*(0.500000000000000005911074e0 +
+		     (0.416666666666660876512776e-1 +
+		      (0.138888888889814854814536e-2 +
+		       (0.248015872460622433115785e-4 +
+			(0.275573350756016588011357e-6 +
+			 (0.208744349831471353536305e-8 +
+			  0.1163921388172173692062032e-10*dy2)*dy2)*dy2)*dy2)*dy2)*dy2);
+
+      z = sinh_lead[ind]*cdy + cosh_lead[ind]*sdy;
+    }
+
+  if (xneg) z = - z;
+  return (float)z;
+}
+
+weak_alias (__sinhf, sinhf)
diff --git a/src/sqrt.c b/src/sqrt.c
new file mode 100644
index 0000000..14c5b1e
--- /dev/null
+++ b/src/sqrt.c
@@ -0,0 +1,65 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include <emmintrin.h>
+#include <math.h>
+#ifdef WIN64
+#include <fpieee.h>
+#else
+#include <errno.h>
+#endif
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+
+#include "../inc/libm_special.h"
+
+#ifdef WINDOWS
+#pragma function(sqrt)
+#endif
+/*SSE2 contains an instruction SQRTSD. This instruction Computes the square root 
+  of the low-order double-precision floating-point value in an XMM register
+  or in a 64-bit memory location and writes the result in the low-order quadword 
+  of another XMM register. The corresponding intrinsic is _mm_sqrt_sd()*/
+double FN_PROTOTYPE(sqrt)(double x)
+{
+    __m128d X128;
+    double result;
+    UT64 uresult;
+
+    if(x < 0.0)
+    {
+        uresult.u64 = 0xfff8000000000000;
+        __amd_handle_error(DOMAIN, EDOM, "sqrt", x, 0.0 , uresult.f64);
+        return uresult.f64;
+    }
+    /*Load x into an XMM register*/
+    X128 = _mm_load_sd(&x);
+    /*Calculate sqrt using SQRTSD instrunction*/
+    X128 = _mm_sqrt_sd(X128, X128);
+    /*Store back the result into a double precision floating point number*/
+    _mm_store_sd(&result, X128);
+    return result;
+}
+
+
diff --git a/src/sqrtf.c b/src/sqrtf.c
new file mode 100644
index 0000000..48e53cd
--- /dev/null
+++ b/src/sqrtf.c
@@ -0,0 +1,73 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include <emmintrin.h>
+#include <math.h>
+#ifdef WIN64
+#include <fpieee.h>
+#else
+#include <errno.h>
+#endif
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+
+#include "../inc/libm_special.h"
+
+#ifdef WINDOWS
+#pragma function(sqrtf)
+#endif
+/*SSE2 contains an instruction SQRTSS. This instruction Computes the square root 
+  of the low-order single-precision floating-point value in an XMM register
+  or in a 32-bit memory location and writes the result in the low-order doubleword 
+  of another XMM register. The corresponding intrinsic is _mm_sqrt_ss()*/
+float FN_PROTOTYPE(sqrtf)(float x)
+{
+    __m128 X128;
+    float result;
+    UT32 uresult;
+
+    if(x < 0.0)
+    {
+        uresult.u32 = 0xffc00000;
+
+        {
+            unsigned int is_x_snan;
+            UT32 xm; xm.f32 = x;
+            is_x_snan = ( ((xm.u32 & QNAN_MASK_32) == 0) ? 1 : 0 );
+            __amd_handle_errorf(DOMAIN, EDOM, "sqrt", x, is_x_snan, 0.0f, 0, uresult.f32, 0);
+        }
+
+        return uresult.f32;
+    }
+
+    /*Load x into an XMM register*/
+    X128 = _mm_load_ss(&x);
+    /*Calculate sqrt using SQRTSS instrunction*/
+    X128 = _mm_sqrt_ss(X128);
+    /*Store back the result into a single precision floating point number*/
+    _mm_store_ss(&result, X128);
+    return result;
+}
+
+
diff --git a/src/tan.c b/src/tan.c
new file mode 100644
index 0000000..a7fe651
--- /dev/null
+++ b/src/tan.c
@@ -0,0 +1,260 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+#define USE_NAN_WITH_FLAGS
+#define USE_VAL_WITH_FLAGS
+#define USE_HANDLE_ERROR
+#include "../inc/libm_inlines_amd.h"
+#undef USE_NAN_WITH_FLAGS
+#undef USE_VAL_WITH_FLAGS
+#undef USE_HANDLE_ERROR
+
+#ifdef WINDOWS
+#include "../inc/libm_errno_amd.h"
+#endif
+
+extern void __amd_remainder_piby2(double x, double *r, double *rr, int *region);
+
+/* tan(x + xx) approximation valid on the interval [-pi/4,pi/4].
+   If recip is true return -1/tan(x + xx) instead. */
+static inline double tan_piby4(double x, double xx, int recip)
+{
+  double r, t1, t2, xl;
+  int transform = 0;
+  static const double
+     piby4_lead = 7.85398163397448278999e-01, /* 0x3fe921fb54442d18 */
+     piby4_tail = 3.06161699786838240164e-17; /* 0x3c81a62633145c06 */
+
+  /* In order to maintain relative precision transform using the identity:
+     tan(pi/4-x) = (1-tan(x))/(1+tan(x)) for arguments close to pi/4.
+     Similarly use tan(x-pi/4) = (tan(x)-1)/(tan(x)+1) close to -pi/4. */
+
+  if (x > 0.68)
+    {
+      transform = 1;
+      x = piby4_lead - x;
+      xl = piby4_tail - xx;
+      x += xl;
+      xx = 0.0;
+    }
+  else if (x < -0.68)
+    {
+      transform = -1;
+      x = piby4_lead + x;
+      xl = piby4_tail + xx;
+      x += xl;
+      xx = 0.0;
+    }
+
+  /* Core Remez [2,3] approximation to tan(x+xx) on the
+     interval [0,0.68]. */
+
+  r = x*x + 2.0 * x * xx;
+  t1 = x;
+  t2 = xx + x*r*
+    (0.372379159759792203640806338901e0 +
+     (-0.229345080057565662883358588111e-1 +
+      0.224044448537022097264602535574e-3*r)*r)/
+    (0.111713747927937668539901657944e1 +
+     (-0.515658515729031149329237816945e0 +
+      (0.260656620398645407524064091208e-1 -
+       0.232371494088563558304549252913e-3*r)*r)*r);
+
+  /* Reconstruct tan(x) in the transformed case. */
+
+  if (transform)
+    {
+      double t;
+      t = t1 + t2;
+      if (recip)
+         return transform*(2*t/(t-1) - 1.0);
+      else
+         return transform*(1.0 - 2*t/(1+t));
+    }
+
+  if (recip)
+    {
+      /* Compute -1.0/(t1 + t2) accurately */
+      double trec, trec_top, z1, z2, t;
+      unsigned long long u;
+      t = t1 + t2;
+      GET_BITS_DP64(t, u);
+      u &= 0xffffffff00000000;
+      PUT_BITS_DP64(u, z1);
+      z2 = t2 - (z1 - t1);
+      trec = -1.0 / t;
+      GET_BITS_DP64(trec, u);
+      u &= 0xffffffff00000000;
+      PUT_BITS_DP64(u, trec_top);
+      return trec_top + trec * ((1.0 + trec_top * z1) + trec_top * z2);
+
+    }
+  else
+    return t1 + t2;
+}
+
+#ifdef WINDOWS
+#pragma function(tan)
+#endif
+
+double FN_PROTOTYPE(tan)(double x)
+{
+  double r, rr;
+  int region, xneg;
+
+  unsigned long long ux, ax;
+  GET_BITS_DP64(x, ux);
+  ax = (ux & ~SIGNBIT_DP64);
+  if (ax <= 0x3fe921fb54442d18) /* abs(x) <= pi/4 */
+    {
+      if (ax < 0x3f20000000000000) /* abs(x) < 2.0^(-13) */
+        {
+          if (ax < 0x3e40000000000000) /* abs(x) < 2.0^(-27) */
+	    {
+	      if (ax == 0x0000000000000000) return x;
+              else return val_with_flags(x, AMD_F_INEXACT);
+	    }
+          else
+            {
+#ifdef WINDOWS
+              /* Using a temporary variable prevents 64-bit VC++ from
+                 rearranging
+                    x + x*x*x*0.333333333333333333;
+                 into
+                    x * (1 + x*x*0.333333333333333333);
+                 The latter results in an incorrectly rounded answer. */
+              double tmp;
+              tmp = x*x*x*0.333333333333333333;
+              return x + tmp;
+#else
+              return x + x*x*x*0.333333333333333333;
+#endif
+            }
+        }
+      else
+        return tan_piby4(x, 0.0, 0);
+    }
+  else if ((ux & EXPBITS_DP64) == EXPBITS_DP64)
+    {
+      /* x is either NaN or infinity */
+      if (ux & MANTBITS_DP64)
+        /* x is NaN */
+#ifdef WINDOWS
+        return handle_error("tan", ux|0x0008000000000000, _DOMAIN, 0,
+                            EDOM, x, 0.0);
+#else
+        return x + x; /* Raise invalid if it is a signalling NaN */
+#endif
+      else
+        /* x is infinity. Return a NaN */
+#ifdef WINDOWS
+        return handle_error("tan", INDEFBITPATT_DP64, _DOMAIN, 0,
+                            EDOM, x, 0.0);
+#else
+        return nan_with_flags(AMD_F_INVALID);
+#endif
+    }
+  xneg = (ax != ux);
+
+
+  if (xneg)
+    x = -x;
+
+  if (x < 5.0e5)
+    {
+      /* For these size arguments we can just carefully subtract the
+         appropriate multiple of pi/2, using extra precision where
+         x is close to an exact multiple of pi/2 */
+      static const double
+        twobypi =  6.36619772367581382433e-01, /* 0x3fe45f306dc9c883 */
+        piby2_1  =  1.57079632673412561417e+00, /* 0x3ff921fb54400000 */
+        piby2_1tail =  6.07710050650619224932e-11, /* 0x3dd0b4611a626331 */
+        piby2_2  =  6.07710050630396597660e-11, /* 0x3dd0b4611a600000 */
+        piby2_2tail =  2.02226624879595063154e-21, /* 0x3ba3198a2e037073 */
+        piby2_3  =  2.02226624871116645580e-21, /* 0x3ba3198a2e000000 */
+        piby2_3tail =  8.47842766036889956997e-32; /* 0x397b839a252049c1 */
+      double t, rhead, rtail;
+      int npi2;
+      unsigned long long uy, xexp, expdiff;
+      xexp  = ax >> EXPSHIFTBITS_DP64;
+      /* How many pi/2 is x a multiple of? */
+      if (ax <= 0x400f6a7a2955385e) /* 5pi/4 */
+        {
+          if (ax <= 0x4002d97c7f3321d2) /* 3pi/4 */
+            npi2 = 1;
+          else
+            npi2 = 2;
+        }
+      else if (ax <= 0x401c463abeccb2bb) /* 9pi/4 */
+        {
+          if (ax <= 0x4015fdbbe9bba775) /* 7pi/4 */
+            npi2 = 3;
+          else
+            npi2 = 4;
+        }
+      else
+        npi2  = (int)(x * twobypi + 0.5);
+      /* Subtract the multiple from x to get an extra-precision remainder */
+      rhead  = x - npi2 * piby2_1;
+      rtail  = npi2 * piby2_1tail;
+      GET_BITS_DP64(rhead, uy);
+      expdiff = xexp - ((uy & EXPBITS_DP64) >> EXPSHIFTBITS_DP64);
+      if (expdiff > 15)
+        {
+          /* The remainder is pretty small compared with x, which
+             implies that x is a near multiple of pi/2
+             (x matches the multiple to at least 15 bits) */
+          t  = rhead;
+          rtail  = npi2 * piby2_2;
+          rhead  = t - rtail;
+          rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+          if (expdiff > 48)
+            {
+              /* x matches a pi/2 multiple to at least 48 bits */
+              t  = rhead;
+              rtail  = npi2 * piby2_3;
+              rhead  = t - rtail;
+              rtail  = npi2 * piby2_3tail - ((t - rhead) - rtail);
+            }
+        }
+      r = rhead - rtail;
+      rr = (rhead - r) - rtail;
+      region = npi2 & 3;
+    }
+  else
+    {
+      /* Reduce x into range [-pi/4,pi/4] */
+       __amd_remainder_piby2(x, &r, &rr, &region);
+     /* __remainder_piby2(x, &r, &rr, &region);*/
+    }
+
+  if (xneg)
+    return -tan_piby4(r, rr, region & 1);
+  else
+    return tan_piby4(r, rr, region & 1);
+}
+
+weak_alias (__tan, tan)
diff --git a/src/tanf.c b/src/tanf.c
new file mode 100644
index 0000000..856cdcf
--- /dev/null
+++ b/src/tanf.c
@@ -0,0 +1,203 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+
+/*#define USE_REMAINDER_PIBY2F_INLINE*/
+#define USE_VALF_WITH_FLAGS
+#define USE_NANF_WITH_FLAGS
+#define USE_HANDLE_ERRORF
+#include "../inc/libm_inlines_amd.h"
+#undef USE_VALF_WITH_FLAGS
+#undef USE_NANF_WITH_FLAGS
+/*#undef USE_REMAINDER_PIBY2F_INLINE*/
+#undef USE_HANDLE_ERRORF
+
+#ifdef WINDOWS
+#include "../inc/libm_errno_amd.h"
+#endif
+
+extern void __amd_remainder_piby2d2f(unsigned long long ux, double *r, int *region);
+
+/* tan(x) approximation valid on the interval [-pi/4,pi/4].
+   If recip is true return -1/tan(x) instead. */
+static inline double tanf_piby4(double x, int recip)
+{
+  double r, t;
+
+  /* Core Remez [1,2] approximation to tan(x) on the
+     interval [0,pi/4]. */
+  r = x*x;
+  t = x + x*r*
+    (0.385296071263995406715129e0 -
+     0.172032480471481694693109e-1 * r) /
+    (0.115588821434688393452299e+1 +
+     (-0.51396505478854532132342e0 +
+      0.1844239256901656082986661e-1 * r) * r);
+
+  if (recip)
+    return -1.0 / t;
+  else
+    return t;
+}
+
+#ifdef WINDOWS
+#pragma function(tanf)
+#endif
+
+float FN_PROTOTYPE(tanf)(float x)
+{
+  double r, dx;
+  int region, xneg;
+
+  unsigned long long ux, ax;
+
+  dx = x;
+
+  GET_BITS_DP64(dx, ux);
+  ax = (ux & ~SIGNBIT_DP64);
+
+  if (ax <= 0x3fe921fb54442d18LL) /* abs(x) <= pi/4 */
+    {
+      if (ax < 0x3f80000000000000LL) /* abs(x) < 2.0^(-7) */
+        {
+          if (ax < 0x3f20000000000000LL) /* abs(x) < 2.0^(-13) */
+            {
+              if (ax == 0x0000000000000000LL)
+                return x;
+              else
+                return valf_with_flags(x, AMD_F_INEXACT);
+            }
+          else
+            return (float)(dx + dx*dx*dx*0.333333333333333333);
+        }
+      else
+        return (float)tanf_piby4(x, 0);
+    }
+  else if ((ux & EXPBITS_DP64) == EXPBITS_DP64)
+    {
+      /* x is either NaN or infinity */
+      if (ux & MANTBITS_DP64)
+        {
+          /* x is NaN */
+#ifdef WINDOWS
+          unsigned int ufx;
+          GET_BITS_SP32(x, ufx);
+          return handle_errorf("tanf", ufx|0x00400000, _DOMAIN, 0,
+                               EDOM, x, 0.0F);
+#else
+          return x + x; /* Raise invalid if it is a signalling NaN */
+#endif
+        }
+      else
+        {
+          /* x is infinity. Return a NaN */
+#ifdef WINDOWS
+          return handle_errorf("tanf", INDEFBITPATT_SP32, _DOMAIN, 0,
+                               EDOM, x, 0.0F);
+#else
+          return nanf_with_flags(AMD_F_INVALID);
+#endif
+        }
+    }
+
+  xneg = (int)(ux >> 63);
+
+  if (xneg)
+    dx = -dx;
+
+  if (dx < 5.0e5)
+    {
+      /* For these size arguments we can just carefully subtract the
+         appropriate multiple of pi/2, using extra precision where
+         dx is close to an exact multiple of pi/2 */
+      static const double
+        twobypi =  6.36619772367581382433e-01, /* 0x3fe45f306dc9c883 */
+        piby2_1  =  1.57079632673412561417e+00, /* 0x3ff921fb54400000 */
+        piby2_1tail =  6.07710050650619224932e-11, /* 0x3dd0b4611a626331 */
+        piby2_2  =  6.07710050630396597660e-11, /* 0x3dd0b4611a600000 */
+        piby2_2tail =  2.02226624879595063154e-21, /* 0x3ba3198a2e037073 */
+        piby2_3  =  2.02226624871116645580e-21, /* 0x3ba3198a2e000000 */
+        piby2_3tail =  8.47842766036889956997e-32; /* 0x397b839a252049c1 */
+      double t, rhead, rtail;
+      int npi2;
+      unsigned long long uy, xexp, expdiff;
+      xexp  = ax >> EXPSHIFTBITS_DP64;
+      /* How many pi/2 is dx a multiple of? */
+      if (ax <= 0x400f6a7a2955385eLL) /* 5pi/4 */
+        {
+          if (ax <= 0x4002d97c7f3321d2LL) /* 3pi/4 */
+            npi2 = 1;
+          else
+            npi2 = 2;
+        }
+      else if (ax <= 0x401c463abeccb2bbLL) /* 9pi/4 */
+        {
+          if (ax <= 0x4015fdbbe9bba775LL) /* 7pi/4 */
+            npi2 = 3;
+          else
+            npi2 = 4;
+        }
+      else
+        npi2  = (int)(dx * twobypi + 0.5);
+      /* Subtract the multiple from dx to get an extra-precision remainder */
+      rhead  = dx - npi2 * piby2_1;
+      rtail  = npi2 * piby2_1tail;
+      GET_BITS_DP64(rhead, uy);
+      expdiff = xexp - ((uy & EXPBITS_DP64) >> EXPSHIFTBITS_DP64);
+      if (expdiff > 15)
+        {
+          /* The remainder is pretty small compared with dx, which
+             implies that dx is a near multiple of pi/2
+             (dx matches the multiple to at least 15 bits) */
+          t  = rhead;
+          rtail  = npi2 * piby2_2;
+          rhead  = t - rtail;
+          rtail  = npi2 * piby2_2tail - ((t - rhead) - rtail);
+          if (expdiff > 48)
+            {
+              /* dx matches a pi/2 multiple to at least 48 bits */
+              t  = rhead;
+              rtail  = npi2 * piby2_3;
+              rhead  = t - rtail;
+              rtail  = npi2 * piby2_3tail - ((t - rhead) - rtail);
+            }
+        }
+      r = rhead - rtail;
+      region = npi2 & 3;
+    }
+  else
+    { 
+		/* Reduce x into range [-pi/4,pi/4] */
+		__amd_remainder_piby2d2f(ax, &r, &region);
+    }
+
+  if (xneg)
+    return (float)-tanf_piby4(r, region & 1);
+  else
+    return (float)tanf_piby4(r, region & 1);
+}
+
+weak_alias (__tanf, tanf)
diff --git a/src/tanh.c b/src/tanh.c
new file mode 100644
index 0000000..ead758b
--- /dev/null
+++ b/src/tanh.c
@@ -0,0 +1,129 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+
+#define USE_SPLITEXP
+#define USE_SCALEDOUBLE_2
+#define USE_VAL_WITH_FLAGS
+#include "../inc/libm_inlines_amd.h"
+#undef USE_SPLITEXP
+#undef USE_SCALEDOUBLE_2
+#undef USE_VAL_WITH_FLAGS
+
+double FN_PROTOTYPE(tanh)(double x)
+{
+  /*
+    The definition of tanh(x) is sinh(x)/cosh(x), which is also equivalent
+    to the following three formulae:
+    1.  (exp(x) - exp(-x))/(exp(x) + exp(-x))
+    2.  (1 - (2/(exp(2*x) + 1 )))
+    3.  (exp(2*x) - 1)/(exp(2*x) + 1)
+    but computationally, some formulae are better on some ranges.
+  */
+  static const double
+    thirtytwo_by_log2 = 4.61662413084468283841e+01, /* 0x40471547652b82fe */
+    log2_by_32_lead = 2.16608493356034159660e-02, /* 0x3f962e42fe000000 */
+    log2_by_32_tail = 5.68948749532545630390e-11, /* 0x3dcf473de6af278e */
+    large_threshold = 20.0; /* 0x4034000000000000 */
+
+  unsigned long long ux, aux, xneg;
+  double y, z, p, z1, z2;
+  int m;
+
+  /* Special cases */
+
+  GET_BITS_DP64(x, ux);
+  aux = ux & ~SIGNBIT_DP64;
+  if (aux < 0x3e30000000000000) /* |x| small enough that tanh(x) = x */
+    {
+      if (aux == 0)
+        return x; /* with no inexact */
+      else
+        return val_with_flags(x, AMD_F_INEXACT);
+    }
+  else if (aux > 0x7ff0000000000000) /* |x| is NaN */
+    return x + x;
+
+  xneg = (aux != ux);
+
+  y = x;
+  if (xneg) y = -x;
+
+  if (y > large_threshold)
+    {
+      /* If x is large then exp(-x) is negligible and
+         formula 1 reduces to plus or minus 1.0 */
+      z = 1.0;
+    }
+  else if (y <= 1.0)
+    {
+      double y2;
+      y2 = y*y;
+      if (y < 0.9)
+        {
+          /* Use a [3,3] Remez approximation on [0,0.9]. */
+          z = y + y*y2*
+            (-0.274030424656179760118928e0 +
+             (-0.176016349003044679402273e-1 +
+              (-0.200047621071909498730453e-3 -
+               0.142077926378834722618091e-7*y2)*y2)*y2)/
+            (0.822091273968539282568011e0 +
+             (0.381641414288328849317962e0 +
+              (0.201562166026937652780575e-1 +
+               0.2091140262529164482568557e-3*y2)*y2)*y2);
+        }
+      else
+        {
+          /* Use a [3,3] Remez approximation on [0.9,1]. */
+          z = y + y*y2*
+            (-0.227793870659088295252442e0 +
+             (-0.146173047288731678404066e-1 +
+              (-0.165597043903549960486816e-3 -
+               0.115475878996143396378318e-7*y2)*y2)*y2)/
+            (0.683381611977295894959554e0 +
+             (0.317204558977294374244770e0 +
+              (0.167358775461896562588695e-1 +
+               0.173076050126225961768710e-3*y2)*y2)*y2);
+        }
+    }
+  else
+    {
+      /* Compute p = exp(2*y) + 1. The code is basically inlined
+         from exp_amd. */
+
+      splitexp(2*y, 1.0, thirtytwo_by_log2, log2_by_32_lead,
+	       log2_by_32_tail, &m, &z1, &z2);
+      p = scaleDouble_2(z1 + z2, m) + 1.0;
+
+      /* Now reconstruct tanh from p. */
+      z = (1.0 - 2.0/p);
+    }
+
+  if (xneg) z = - z;
+  return z;
+}
+
+weak_alias (__tanh, tanh)
diff --git a/src/tanhf.c b/src/tanhf.c
new file mode 100644
index 0000000..1cb14c4
--- /dev/null
+++ b/src/tanhf.c
@@ -0,0 +1,126 @@
+
+/*
+*  Copyright (C) 2008-2009 Advanced Micro Devices, Inc. All Rights Reserved.
+*
+*  This file is part of libacml_mv.
+*
+*  libacml_mv is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU Lesser General Public
+*  License as published by the Free Software Foundation; either
+*  version 2.1 of the License, or (at your option) any later version.
+*
+*  libacml_mv 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
+*  Lesser General Public License for more details.
+*
+*  You should have received a copy of the GNU Lesser General Public
+*  License along with libacml_mv.  If not, see
+*  <http://www.gnu.org/licenses/>.
+*
+*/
+
+
+
+#include "../inc/libm_amd.h"
+#include "../inc/libm_util_amd.h"
+
+
+
+#define USE_SPLITEXPF
+#define USE_SCALEFLOAT_2
+#define USE_VALF_WITH_FLAGS
+#include "../inc/libm_inlines_amd.h"
+#undef USE_SPLITEXPF
+#undef USE_SCALEFLOAT_2
+#undef USE_VALF_WITH_FLAGS
+
+#include "../inc/libm_errno_amd.h"
+
+float FN_PROTOTYPE(tanhf)(float x)
+{
+  /*
+    The definition of tanh(x) is sinh(x)/cosh(x), which is also equivalent
+    to the following three formulae:
+    1.  (exp(x) - exp(-x))/(exp(x) + exp(-x))
+    2.  (1 - (2/(exp(2*x) + 1 )))
+    3.  (exp(2*x) - 1)/(exp(2*x) + 1)
+    but computationally, some formulae are better on some ranges.
+  */
+  static const float
+    thirtytwo_by_log2 =  4.6166240692e+01F, /* 0x4238aa3b */
+    log2_by_32_lead =  2.1659851074e-02F, /* 0x3cb17000 */
+    log2_by_32_tail =  9.9831822808e-07F, /* 0x3585fdf4 */
+    large_threshold = 10.0F; /* 0x41200000 */
+
+  unsigned int ux, aux;
+  float y, z, p, z1, z2, xneg;
+  int m;
+
+  /* Special cases */
+
+  GET_BITS_SP32(x, ux);
+  aux = ux & ~SIGNBIT_SP32;
+  if (aux < 0x39000000) /* |x| small enough that tanh(x) = x */
+    {
+      if (aux == 0)
+        return x; /* with no inexact */
+      else
+        return valf_with_flags(x, AMD_F_INEXACT);
+    }
+  else if (aux > 0x7f800000) /* |x| is NaN */
+    return x + x;
+
+  xneg = 1.0F - 2.0F * (aux != ux);
+
+  y = xneg * x;
+
+  if (y > large_threshold)
+    {
+      /* If x is large then exp(-x) is negligible and
+         formula 1 reduces to plus or minus 1.0 */
+      z = 1.0F;
+    }
+  else if (y <= 1.0F)
+    {
+      float y2;
+      y2 = y*y;
+
+      if (y < 0.9F)
+        {
+          /* Use a [2,1] Remez approximation on [0,0.9]. */
+          z = y + y*y2*
+            (-0.28192806108402678e0F +
+             (-0.14628356048797849e-2F +
+              0.4891631088530669873e-4F*y2)*y2)/
+            (0.845784192581041099e0F +
+             0.3427017942262751343e0F*y2);
+        }
+      else
+        {
+          /* Use a [2,1] Remez approximation on [0.9,1]. */
+          z = y + y*y2*
+            (-0.24069858695196524e0F +
+             (-0.12325644183611929e-2F +
+              0.3827534993599483396e-4F*y2)*y2)/
+            (0.72209738473684982e0F +
+             0.292529068698052819e0F*y2);
+        }
+    }
+  else
+    {
+      /* Compute p = exp(2*y) + 1. The code is basically inlined
+         from exp_amd. */
+
+      splitexpf(2*y, 1.0F, thirtytwo_by_log2, log2_by_32_lead,
+	       log2_by_32_tail, &m, &z1, &z2);
+      p = scaleFloat_2(z1 + z2, m) + 1.0F;
+      /* Now reconstruct tanh from p. */
+      z = (1.0F - 2.0F/p);
+    }
+
+  return xneg * z;
+}
+
+
+weak_alias (__tanhf, tanhf)
diff --git a/testdata/exp.rephil_docs.builtin.baseline.trace b/testdata/exp.rephil_docs.builtin.baseline.trace
new file mode 100644
index 0000000..8344f12
--- /dev/null
+++ b/testdata/exp.rephil_docs.builtin.baseline.trace
Binary files differ
diff --git a/testdata/expf.fastmath_unittest.trace b/testdata/expf.fastmath_unittest.trace
new file mode 100644
index 0000000..c867b36
--- /dev/null
+++ b/testdata/expf.fastmath_unittest.trace
Binary files differ
diff --git a/testdata/log.rephil_docs.builtin.baseline.trace b/testdata/log.rephil_docs.builtin.baseline.trace
new file mode 100644
index 0000000..e87d631
--- /dev/null
+++ b/testdata/log.rephil_docs.builtin.baseline.trace
Binary files differ
diff --git a/testdata/notes.txt b/testdata/notes.txt
new file mode 100644
index 0000000..8b5884f
--- /dev/null
+++ b/testdata/notes.txt
@@ -0,0 +1,23 @@
+The traces in this directory are used for validating and testing
+performance of the math library. Each file contains the input
+arguments to the specific math functions, written in raw binary
+format.
+
+exp,log,pow are collected from the Perflab benchmark
+compiler/rephil/docs/v7 and expf is collected from
+util/math:fastmath_unittest.
+
+The traces were collected by linking in a small library that wrote
+that first 4M arguments to file before returning the actual value.
+ - Library was added as a dep to "base:base".
+ - To avoid write samples for genrules, the profiling was guarded by a
+   macro that was defined using --copt.
+ - Tcmalloc holds a lock while it calls log(), so care had to be taken
+   not to cause a deadlock in the profiling of log().
+   For the other functions, the actual value could be calculated
+   using something like this:
+     _exp = (double (*)(double)) dlsym(RTLD_NEXT, "exp");
+     return _exp(x);
+   for log(), we made the following call:
+     return log10(x)/log10(2.71828182846);
+
diff --git a/testdata/pow.rephil_docs.builtin.baseline.trace b/testdata/pow.rephil_docs.builtin.baseline.trace
new file mode 100644
index 0000000..b7a9722
--- /dev/null
+++ b/testdata/pow.rephil_docs.builtin.baseline.trace
Binary files differ